/**
 *
 */
import Util;
import OpenApi;
import OpenApiUtil;
import EndpointUtil;

extends OpenApi;


init(config: OpenApi.Config){
  super(config);
  @signatureAlgorithm = 'v2';
  @endpointRule = '';
  
  checkConfig(config);
  @endpoint = getEndpoint('dypls', @regionId, @endpointRule, @network, @suffix, @endpointMap, @endpoint);
}

function getEndpoint(productId: string, regionId: string, endpointRule: string, network: string, suffix: string, endpointMap: map[string]string, endpoint: string) throws: string{
  if (!Util.empty(endpoint)) {
    return endpoint;
  }
  
  if (!Util.isUnset(endpointMap) && !Util.empty(endpointMap[regionId])) {
    return endpointMap[regionId];
  }
  return EndpointUtil.getEndpointRules(productId, regionId, endpointRule, network, suffix);
}

model ApplyArInvoiceWithSourceRequest {
  address?: {
    addressId?: string(name='AddressId'),
    appCode?: string(name='AppCode'),
    city?: string(name='City'),
    country?: string(name='Country'),
    creator?: string(name='Creator'),
    customer?: {
      appCode?: string(name='AppCode'),
      customerId?: string(name='CustomerId'),
      customerSite?: string(name='CustomerSite'),
      customerSystem?: string(name='CustomerSystem'),
      encryptProps?: map[string]string(name='EncryptProps'),
      language?: string(name='Language'),
      sign?: string(name='Sign'),
      uuid?: string(name='Uuid'),
    }(name='Customer'),
    detailedAddress?: string(name='DetailedAddress'),
    district?: string(name='District'),
    encryptProps?: map[string]string(name='EncryptProps'),
    fixedNumber?: string(name='FixedNumber'),
    fullAddress?: string(name='FullAddress'),
    isDefault?: boolean(name='IsDefault'),
    isEffective?: boolean(name='IsEffective'),
    language?: string(name='Language'),
    mobileNumber?: string(name='MobileNumber'),
    province?: string(name='Province'),
    recipientName?: string(name='RecipientName'),
    relatedId?: string(name='RelatedId'),
    relatedSystem?: string(name='RelatedSystem'),
    sign?: string(name='Sign'),
    street?: string(name='Street'),
    uuid?: string(name='Uuid'),
    zipCode?: string(name='ZipCode'),
  }(name='Address'),
  amount?: double(name='Amount'),
  appCode?: string(name='AppCode'),
  applier?: string(name='Applier'),
  applyDate?: string(name='ApplyDate'),
  currencyCode?: string(name='CurrencyCode'),
  customer?: {
    appCode?: string(name='AppCode'),
    customerId?: string(name='CustomerId'),
    customerSite?: string(name='CustomerSite'),
    customerSystem?: string(name='CustomerSystem'),
    encryptProps?: map[string]string(name='EncryptProps'),
    language?: string(name='Language'),
    sign?: string(name='Sign'),
    uuid?: string(name='Uuid'),
  }(name='Customer'),
  encryptProps?: map[string]string(name='EncryptProps'),
  excludingTaxAmount?: double(name='ExcludingTaxAmount'),
  inputType?: string(name='InputType'),
  invoiceType?: string(name='InvoiceType'),
  isMerged?: boolean(name='IsMerged'),
  language?: string(name='Language'),
  materialType?: string(name='MaterialType'),
  memo?: string(name='Memo'),
  ouCode?: string(name='OuCode'),
  purchaserBankInfo?: string(name='PurchaserBankInfo'),
  purchaserContactInfo?: string(name='PurchaserContactInfo'),
  purchaserName?: string(name='PurchaserName'),
  purchaserTaxNo?: string(name='PurchaserTaxNo'),
  requestNo?: string(name='RequestNo'),
  sign?: string(name='Sign'),
  siteId?: string(name='SiteId'),
  sourceList?: [ 
    {
      amount?: double(name='Amount'),
      appCode?: string(name='AppCode'),
      billAmount?: double(name='BillAmount'),
      billDomain?: string(name='BillDomain'),
      billNo?: string(name='BillNo'),
      billType?: string(name='BillType'),
      blueSourceId?: long(name='BlueSourceId'),
      canMerge?: boolean(name='CanMerge'),
      cargoName?: string(name='CargoName'),
      category?: string(name='Category'),
      companyName?: string(name='CompanyName'),
      currencyCode?: string(name='CurrencyCode'),
      customer?: {
        appCode?: string(name='AppCode'),
        customerId?: string(name='CustomerId'),
        customerSite?: string(name='CustomerSite'),
        customerSystem?: string(name='CustomerSystem'),
        encryptProps?: map[string]string(name='EncryptProps'),
        language?: string(name='Language'),
        sign?: string(name='Sign'),
        uuid?: string(name='Uuid'),
      }(name='Customer'),
      discountAmount?: double(name='DiscountAmount'),
      discountTaxAmount?: double(name='DiscountTaxAmount'),
      encryptProps?: map[string]string(name='EncryptProps'),
      excludingTaxAmount?: double(name='ExcludingTaxAmount'),
      excludingTaxDiscountAmount?: double(name='ExcludingTaxDiscountAmount'),
      excludingTaxRedAmount?: double(name='ExcludingTaxRedAmount'),
      excludingTaxRemainAmount?: double(name='ExcludingTaxRemainAmount'),
      gmtBill?: string(name='GmtBill'),
      gmtBillEnd?: string(name='GmtBillEnd'),
      gmtBillStart?: string(name='GmtBillStart'),
      gmtBuild?: string(name='GmtBuild'),
      isApply?: string(name='IsApply'),
      language?: string(name='Language'),
      majorBillNo?: string(name='MajorBillNo'),
      model?: string(name='Model'),
      ouCode?: string(name='OuCode'),
      parentCategory?: string(name='ParentCategory'),
      productDomain?: string(name='ProductDomain'),
      productId?: string(name='ProductId'),
      productName?: string(name='ProductName'),
      quantity?: double(name='Quantity'),
      quantityUnit?: string(name='QuantityUnit'),
      redAmount?: double(name='RedAmount'),
      relatedId?: string(name='RelatedId'),
      remainAmount?: double(name='RemainAmount'),
      revenueType?: string(name='RevenueType'),
      serviceName?: string(name='ServiceName'),
      sign?: string(name='Sign'),
      siteId?: string(name='SiteId'),
      sourceId?: long(name='SourceId'),
      taxAmount?: double(name='TaxAmount'),
      taxRate?: double(name='TaxRate'),
      unitPrice?: double(name='UnitPrice'),
      uuid?: string(name='Uuid'),
    }
  ](name='SourceList'),
  taxAmount?: double(name='TaxAmount'),
  uuid?: string(name='Uuid'),
}

model ApplyArInvoiceWithSourceResponseBody = {
  errorCode?: string(name='ErrorCode'),
  errorMessage?: string(name='ErrorMessage'),
  isSuccess?: boolean(name='IsSuccess'),
  returnValue?: {
    encryptProps?: map[string]string(name='EncryptProps'),
    outerSystemEncryptStr?: string(name='OuterSystemEncryptStr'),
    outerSystemSignStr?: string(name='OuterSystemSignStr'),
    sign?: string(name='Sign'),
  }(name='ReturnValue'),
}

model ApplyArInvoiceWithSourceResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ApplyArInvoiceWithSourceResponseBody(name='body'),
}

async function applyArInvoiceWithSourceWithOptions(request: ApplyArInvoiceWithSourceRequest, runtime: Util.RuntimeOptions): ApplyArInvoiceWithSourceResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  var bodyFlat : map[string]any = {};
  if (!Util.isUnset(request.address)) {
    bodyFlat['Address'] = request.address;
  }
  if (!Util.isUnset(request.amount)) {
    body['Amount'] = request.amount;
  }
  if (!Util.isUnset(request.appCode)) {
    body['AppCode'] = request.appCode;
  }
  if (!Util.isUnset(request.applier)) {
    body['Applier'] = request.applier;
  }
  if (!Util.isUnset(request.applyDate)) {
    body['ApplyDate'] = request.applyDate;
  }
  if (!Util.isUnset(request.currencyCode)) {
    body['CurrencyCode'] = request.currencyCode;
  }
  if (!Util.isUnset(request.customer)) {
    bodyFlat['Customer'] = request.customer;
  }
  if (!Util.isUnset(request.encryptProps)) {
    bodyFlat['EncryptProps'] = request.encryptProps;
  }
  if (!Util.isUnset(request.excludingTaxAmount)) {
    body['ExcludingTaxAmount'] = request.excludingTaxAmount;
  }
  if (!Util.isUnset(request.inputType)) {
    body['InputType'] = request.inputType;
  }
  if (!Util.isUnset(request.invoiceType)) {
    body['InvoiceType'] = request.invoiceType;
  }
  if (!Util.isUnset(request.isMerged)) {
    body['IsMerged'] = request.isMerged;
  }
  if (!Util.isUnset(request.language)) {
    body['Language'] = request.language;
  }
  if (!Util.isUnset(request.materialType)) {
    body['MaterialType'] = request.materialType;
  }
  if (!Util.isUnset(request.memo)) {
    body['Memo'] = request.memo;
  }
  if (!Util.isUnset(request.ouCode)) {
    body['OuCode'] = request.ouCode;
  }
  if (!Util.isUnset(request.purchaserBankInfo)) {
    body['PurchaserBankInfo'] = request.purchaserBankInfo;
  }
  if (!Util.isUnset(request.purchaserContactInfo)) {
    body['PurchaserContactInfo'] = request.purchaserContactInfo;
  }
  if (!Util.isUnset(request.purchaserName)) {
    body['PurchaserName'] = request.purchaserName;
  }
  if (!Util.isUnset(request.purchaserTaxNo)) {
    body['PurchaserTaxNo'] = request.purchaserTaxNo;
  }
  if (!Util.isUnset(request.requestNo)) {
    body['RequestNo'] = request.requestNo;
  }
  if (!Util.isUnset(request.sign)) {
    body['Sign'] = request.sign;
  }
  if (!Util.isUnset(request.siteId)) {
    body['SiteId'] = request.siteId;
  }
  if (!Util.isUnset(request.sourceList)) {
    body['SourceList'] = request.sourceList;
  }
  if (!Util.isUnset(request.taxAmount)) {
    body['TaxAmount'] = request.taxAmount;
  }
  if (!Util.isUnset(request.uuid)) {
    body['Uuid'] = request.uuid;
  }
  body = {
    ...body,
    ...OpenApiUtil.query(bodyFlat),
  };

  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'ApplyArInvoiceWithSource',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function applyArInvoiceWithSource(request: ApplyArInvoiceWithSourceRequest): ApplyArInvoiceWithSourceResponse {
  var runtime = new Util.RuntimeOptions{};
  return applyArInvoiceWithSourceWithOptions(request, runtime);
}

model ApplyBlackInfoExportRequest {
  billId?: string(name='BillId'),
  blackType?: string(name='BlackType'),
  ownerId?: long(name='OwnerId'),
  prodCode?: string(name='ProdCode'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
}

model ApplyBlackInfoExportResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: string(name='data'),
}

model ApplyBlackInfoExportResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ApplyBlackInfoExportResponseBody(name='body'),
}

async function applyBlackInfoExportWithOptions(request: ApplyBlackInfoExportRequest, runtime: Util.RuntimeOptions): ApplyBlackInfoExportResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.billId)) {
    query['BillId'] = request.billId;
  }
  if (!Util.isUnset(request.blackType)) {
    query['BlackType'] = request.blackType;
  }
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ApplyBlackInfoExport',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function applyBlackInfoExport(request: ApplyBlackInfoExportRequest): ApplyBlackInfoExportResponse {
  var runtime = new Util.RuntimeOptions{};
  return applyBlackInfoExportWithOptions(request, runtime);
}

model ApplyCallRecordExportRequest {
  billId?: string(name='BillId'),
  callDate?: string(name='CallDate'),
  callId?: string(name='CallId'),
  ownerId?: long(name='OwnerId'),
  phoneNoA?: string(name='PhoneNoA'),
  phoneNoB?: string(name='PhoneNoB'),
  prodCode?: string(name='ProdCode'),
  resType?: int32(name='ResType'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
  secretNo?: string(name='SecretNo'),
}

model ApplyCallRecordExportResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: string(name='data'),
}

model ApplyCallRecordExportResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ApplyCallRecordExportResponseBody(name='body'),
}

async function applyCallRecordExportWithOptions(request: ApplyCallRecordExportRequest, runtime: Util.RuntimeOptions): ApplyCallRecordExportResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.billId)) {
    query['BillId'] = request.billId;
  }
  if (!Util.isUnset(request.callDate)) {
    query['CallDate'] = request.callDate;
  }
  if (!Util.isUnset(request.callId)) {
    query['CallId'] = request.callId;
  }
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.phoneNoA)) {
    query['PhoneNoA'] = request.phoneNoA;
  }
  if (!Util.isUnset(request.phoneNoB)) {
    query['PhoneNoB'] = request.phoneNoB;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.resType)) {
    query['ResType'] = request.resType;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  if (!Util.isUnset(request.secretNo)) {
    query['SecretNo'] = request.secretNo;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ApplyCallRecordExport',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function applyCallRecordExport(request: ApplyCallRecordExportRequest): ApplyCallRecordExportResponse {
  var runtime = new Util.RuntimeOptions{};
  return applyCallRecordExportWithOptions(request, runtime);
}

model ApplyGroupNumberExportRequest {
  groupId?: string(name='GroupId'),
  ownerId?: long(name='OwnerId'),
  poolKey?: string(name='PoolKey'),
  prodCode?: string(name='ProdCode'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
}

model ApplyGroupNumberExportResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: string(name='data'),
}

model ApplyGroupNumberExportResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ApplyGroupNumberExportResponseBody(name='body'),
}

async function applyGroupNumberExportWithOptions(request: ApplyGroupNumberExportRequest, runtime: Util.RuntimeOptions): ApplyGroupNumberExportResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.groupId)) {
    query['GroupId'] = request.groupId;
  }
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.poolKey)) {
    query['PoolKey'] = request.poolKey;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ApplyGroupNumberExport',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function applyGroupNumberExport(request: ApplyGroupNumberExportRequest): ApplyGroupNumberExportResponse {
  var runtime = new Util.RuntimeOptions{};
  return applyGroupNumberExportWithOptions(request, runtime);
}

model ApplyRingToneRequest {
  billId?: string(name='BillId'),
  id?: string(name='Id'),
  ownerId?: long(name='OwnerId'),
  playType?: string(name='PlayType'),
  prodCode?: string(name='ProdCode'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
}

model ApplyRingToneResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: string(name='data'),
}

model ApplyRingToneResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ApplyRingToneResponseBody(name='body'),
}

async function applyRingToneWithOptions(request: ApplyRingToneRequest, runtime: Util.RuntimeOptions): ApplyRingToneResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.billId)) {
    query['BillId'] = request.billId;
  }
  if (!Util.isUnset(request.id)) {
    query['Id'] = request.id;
  }
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.playType)) {
    query['PlayType'] = request.playType;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ApplyRingTone',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function applyRingTone(request: ApplyRingToneRequest): ApplyRingToneResponse {
  var runtime = new Util.RuntimeOptions{};
  return applyRingToneWithOptions(request, runtime);
}

model BatchOccupySecretResRequest {
  batchOccupyList?: [ 
    {
      count?: int32(name='Count'),
      orderDetailId?: long(name='OrderDetailId'),
      orderId?: long(name='OrderId'),
      partnerKey?: string(name='PartnerKey'),
      resType?: long(name='ResType'),
      secretNoType?: long(name='SecretNoType'),
    }
  ](name='BatchOccupyList'),
  ownerId?: long(name='OwnerId'),
  prodCode?: string(name='ProdCode'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
}

model BatchOccupySecretResShrinkRequest {
  batchOccupyListShrink?: string(name='BatchOccupyList'),
  ownerId?: long(name='OwnerId'),
  prodCode?: string(name='ProdCode'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
}

model BatchOccupySecretResResponseBody = {
  code?: string(name='Code'),
  data?: boolean(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model BatchOccupySecretResResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: BatchOccupySecretResResponseBody(name='body'),
}

async function batchOccupySecretResWithOptions(tmpReq: BatchOccupySecretResRequest, runtime: Util.RuntimeOptions): BatchOccupySecretResResponse {
  Util.validateModel(tmpReq);
  var request = new BatchOccupySecretResShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.batchOccupyList)) {
    request.batchOccupyListShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.batchOccupyList, 'BatchOccupyList', 'json');
  }
  var query = {};
  if (!Util.isUnset(request.batchOccupyListShrink)) {
    query['BatchOccupyList'] = request.batchOccupyListShrink;
  }
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'BatchOccupySecretRes',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function batchOccupySecretRes(request: BatchOccupySecretResRequest): BatchOccupySecretResResponse {
  var runtime = new Util.RuntimeOptions{};
  return batchOccupySecretResWithOptions(request, runtime);
}

model BindResourceRequest {
  asrModelId?: string(name='AsrModelId'),
  asrStatus?: boolean(name='AsrStatus'),
  axnExtensionB?: string(name='AxnExtensionB'),
  billId?: string(name='BillId'),
  expTime?: string(name='ExpTime'),
  isRecord?: boolean(name='IsRecord'),
  ownerId?: long(name='OwnerId'),
  phoneNoA?: string(name='PhoneNoA'),
  phoneNoB?: string(name='PhoneNoB'),
  prodCode?: string(name='ProdCode'),
  resType?: int32(name='ResType'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
  secretNo?: string(name='SecretNo'),
}

model BindResourceResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: string(name='data'),
}

model BindResourceResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: BindResourceResponseBody(name='body'),
}

async function bindResourceWithOptions(request: BindResourceRequest, runtime: Util.RuntimeOptions): BindResourceResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.asrModelId)) {
    query['AsrModelId'] = request.asrModelId;
  }
  if (!Util.isUnset(request.asrStatus)) {
    query['AsrStatus'] = request.asrStatus;
  }
  if (!Util.isUnset(request.axnExtensionB)) {
    query['AxnExtensionB'] = request.axnExtensionB;
  }
  if (!Util.isUnset(request.billId)) {
    query['BillId'] = request.billId;
  }
  if (!Util.isUnset(request.expTime)) {
    query['ExpTime'] = request.expTime;
  }
  if (!Util.isUnset(request.isRecord)) {
    query['IsRecord'] = request.isRecord;
  }
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.phoneNoA)) {
    query['PhoneNoA'] = request.phoneNoA;
  }
  if (!Util.isUnset(request.phoneNoB)) {
    query['PhoneNoB'] = request.phoneNoB;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.resType)) {
    query['ResType'] = request.resType;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  if (!Util.isUnset(request.secretNo)) {
    query['SecretNo'] = request.secretNo;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'BindResource',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function bindResource(request: BindResourceRequest): BindResourceResponse {
  var runtime = new Util.RuntimeOptions{};
  return bindResourceWithOptions(request, runtime);
}

model BlackOperateRequest {
  billId?: string(name='BillId'),
  blackMap?: string(name='BlackMap'),
  blackType?: string(name='BlackType'),
  operateType?: string(name='OperateType'),
  ownerId?: long(name='OwnerId'),
  prodCode?: string(name='ProdCode'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
}

model BlackOperateResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: string(name='data'),
  message?: string(name='message'),
}

model BlackOperateResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: BlackOperateResponseBody(name='body'),
}

async function blackOperateWithOptions(request: BlackOperateRequest, runtime: Util.RuntimeOptions): BlackOperateResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.billId)) {
    query['BillId'] = request.billId;
  }
  if (!Util.isUnset(request.blackMap)) {
    query['BlackMap'] = request.blackMap;
  }
  if (!Util.isUnset(request.blackType)) {
    query['BlackType'] = request.blackType;
  }
  if (!Util.isUnset(request.operateType)) {
    query['OperateType'] = request.operateType;
  }
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'BlackOperate',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function blackOperate(request: BlackOperateRequest): BlackOperateResponse {
  var runtime = new Util.RuntimeOptions{};
  return blackOperateWithOptions(request, runtime);
}

model CreateCertifyInfoRequest {
  ownerId?: long(name='OwnerId'),
  phoneNo?: string(name='PhoneNo'),
  prodCode?: string(name='ProdCode'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
}

model CreateCertifyInfoResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: string(name='data'),
}

model CreateCertifyInfoResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: CreateCertifyInfoResponseBody(name='body'),
}

async function createCertifyInfoWithOptions(request: CreateCertifyInfoRequest, runtime: Util.RuntimeOptions): CreateCertifyInfoResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.phoneNo)) {
    query['PhoneNo'] = request.phoneNo;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CreateCertifyInfo',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function createCertifyInfo(request: CreateCertifyInfoRequest): CreateCertifyInfoResponse {
  var runtime = new Util.RuntimeOptions{};
  return createCertifyInfoWithOptions(request, runtime);
}

model CreateContactsRequest {
  billId?: string(name='BillId'),
  name?: string(name='Name'),
  ownerId?: long(name='OwnerId'),
  phoneNumber?: string(name='PhoneNumber'),
  prodCode?: string(name='ProdCode'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
}

model CreateContactsResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: string(name='data'),
}

model CreateContactsResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: CreateContactsResponseBody(name='body'),
}

async function createContactsWithOptions(request: CreateContactsRequest, runtime: Util.RuntimeOptions): CreateContactsResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.billId)) {
    query['BillId'] = request.billId;
  }
  if (!Util.isUnset(request.name)) {
    query['Name'] = request.name;
  }
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.phoneNumber)) {
    query['PhoneNumber'] = request.phoneNumber;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CreateContacts',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function createContacts(request: CreateContactsRequest): CreateContactsResponse {
  var runtime = new Util.RuntimeOptions{};
  return createContactsWithOptions(request, runtime);
}

model CreateGroupDetailRequest {
  groupId?: string(name='GroupId'),
  numberList?: string(name='NumberList'),
  ownerId?: long(name='OwnerId'),
  poolKey?: string(name='PoolKey'),
  prodCode?: string(name='ProdCode'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
}

model CreateGroupDetailResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: boolean(name='data'),
}

model CreateGroupDetailResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: CreateGroupDetailResponseBody(name='body'),
}

async function createGroupDetailWithOptions(request: CreateGroupDetailRequest, runtime: Util.RuntimeOptions): CreateGroupDetailResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.groupId)) {
    query['GroupId'] = request.groupId;
  }
  if (!Util.isUnset(request.numberList)) {
    query['NumberList'] = request.numberList;
  }
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.poolKey)) {
    query['PoolKey'] = request.poolKey;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CreateGroupDetail',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function createGroupDetail(request: CreateGroupDetailRequest): CreateGroupDetailResponse {
  var runtime = new Util.RuntimeOptions{};
  return createGroupDetailWithOptions(request, runtime);
}

model CreateGroupInfoRequest {
  name?: string(name='Name'),
  numberList?: string(name='NumberList'),
  ownerId?: long(name='OwnerId'),
  poolKey?: string(name='PoolKey'),
  prodCode?: string(name='ProdCode'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
}

model CreateGroupInfoResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: boolean(name='data'),
}

model CreateGroupInfoResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: CreateGroupInfoResponseBody(name='body'),
}

async function createGroupInfoWithOptions(request: CreateGroupInfoRequest, runtime: Util.RuntimeOptions): CreateGroupInfoResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.name)) {
    query['Name'] = request.name;
  }
  if (!Util.isUnset(request.numberList)) {
    query['NumberList'] = request.numberList;
  }
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.poolKey)) {
    query['PoolKey'] = request.poolKey;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CreateGroupInfo',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function createGroupInfo(request: CreateGroupInfoRequest): CreateGroupInfoResponse {
  var runtime = new Util.RuntimeOptions{};
  return createGroupInfoWithOptions(request, runtime);
}

model CreateLogicalDeleteRequest {
  bid?: string(name='Bid'),
  country?: string(name='Country'),
  gmtWakeup?: string(name='GmtWakeup'),
  hid?: long(name='Hid'),
  interrupt?: boolean(name='Interrupt'),
  invoker?: string(name='Invoker'),
  message?: string(name='Message'),
  pk?: string(name='Pk'),
  prodCode?: string(name='ProdCode'),
  success?: boolean(name='Success'),
  taskExtraData?: string(name='TaskExtraData'),
  taskIdentifier?: string(name='TaskIdentifier'),
}

model CreateLogicalDeleteResponseBody = {
  bid?: string(name='Bid'),
  country?: string(name='Country'),
  gmtWakeup?: string(name='GmtWakeup'),
  hid?: long(name='Hid'),
  interrupt?: boolean(name='Interrupt'),
  invoker?: string(name='Invoker'),
  message?: string(name='Message'),
  pk?: string(name='Pk'),
  success?: boolean(name='Success'),
  taskExtraData?: string(name='TaskExtraData'),
  taskIdentifier?: string(name='TaskIdentifier'),
}

model CreateLogicalDeleteResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: CreateLogicalDeleteResponseBody(name='body'),
}

async function createLogicalDeleteWithOptions(request: CreateLogicalDeleteRequest, runtime: Util.RuntimeOptions): CreateLogicalDeleteResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.bid)) {
    query['Bid'] = request.bid;
  }
  if (!Util.isUnset(request.country)) {
    query['Country'] = request.country;
  }
  if (!Util.isUnset(request.gmtWakeup)) {
    query['GmtWakeup'] = request.gmtWakeup;
  }
  if (!Util.isUnset(request.hid)) {
    query['Hid'] = request.hid;
  }
  if (!Util.isUnset(request.interrupt)) {
    query['Interrupt'] = request.interrupt;
  }
  if (!Util.isUnset(request.invoker)) {
    query['Invoker'] = request.invoker;
  }
  if (!Util.isUnset(request.message)) {
    query['Message'] = request.message;
  }
  if (!Util.isUnset(request.pk)) {
    query['Pk'] = request.pk;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.success)) {
    query['Success'] = request.success;
  }
  if (!Util.isUnset(request.taskExtraData)) {
    query['TaskExtraData'] = request.taskExtraData;
  }
  if (!Util.isUnset(request.taskIdentifier)) {
    query['TaskIdentifier'] = request.taskIdentifier;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CreateLogicalDelete',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function createLogicalDelete(request: CreateLogicalDeleteRequest): CreateLogicalDeleteResponse {
  var runtime = new Util.RuntimeOptions{};
  return createLogicalDeleteWithOptions(request, runtime);
}

model CreateMessageCallbackRequest {
  bizType?: string(name='BizType'),
  callbackUrl?: string(name='CallbackUrl'),
  ownerId?: long(name='OwnerId'),
  prodCode?: string(name='ProdCode'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
}

model CreateMessageCallbackResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: string(name='data'),
  message?: string(name='message'),
}

model CreateMessageCallbackResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: CreateMessageCallbackResponseBody(name='body'),
}

async function createMessageCallbackWithOptions(request: CreateMessageCallbackRequest, runtime: Util.RuntimeOptions): CreateMessageCallbackResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.bizType)) {
    query['BizType'] = request.bizType;
  }
  if (!Util.isUnset(request.callbackUrl)) {
    query['CallbackUrl'] = request.callbackUrl;
  }
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CreateMessageCallback',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function createMessageCallback(request: CreateMessageCallbackRequest): CreateMessageCallbackResponse {
  var runtime = new Util.RuntimeOptions{};
  return createMessageCallbackWithOptions(request, runtime);
}

model CreateMessageQueueRequest {
  billIds?: string(name='BillIds'),
  bizType?: string(name='BizType'),
  ownerId?: long(name='OwnerId'),
  prodCode?: string(name='ProdCode'),
  queueName?: string(name='QueueName'),
  queueTitle?: string(name='QueueTitle'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
}

model CreateMessageQueueResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: string(name='data'),
}

model CreateMessageQueueResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: CreateMessageQueueResponseBody(name='body'),
}

async function createMessageQueueWithOptions(request: CreateMessageQueueRequest, runtime: Util.RuntimeOptions): CreateMessageQueueResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.billIds)) {
    query['BillIds'] = request.billIds;
  }
  if (!Util.isUnset(request.bizType)) {
    query['BizType'] = request.bizType;
  }
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.queueName)) {
    query['QueueName'] = request.queueName;
  }
  if (!Util.isUnset(request.queueTitle)) {
    query['QueueTitle'] = request.queueTitle;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CreateMessageQueue',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function createMessageQueue(request: CreateMessageQueueRequest): CreateMessageQueueResponse {
  var runtime = new Util.RuntimeOptions{};
  return createMessageQueueWithOptions(request, runtime);
}

model CreatePhysicalDeleteRequest {
  bid?: string(name='Bid'),
  country?: string(name='Country'),
  gmtWakeup?: string(name='GmtWakeup'),
  hid?: long(name='Hid'),
  interrupt?: boolean(name='Interrupt'),
  invoker?: string(name='Invoker'),
  message?: string(name='Message'),
  pk?: string(name='Pk'),
  prodCode?: string(name='ProdCode'),
  success?: boolean(name='Success'),
  taskExtraData?: string(name='TaskExtraData'),
  taskIdentifier?: string(name='TaskIdentifier'),
}

model CreatePhysicalDeleteResponseBody = {
  bid?: string(name='Bid'),
  country?: string(name='Country'),
  gmtWakeup?: string(name='GmtWakeup'),
  hid?: long(name='Hid'),
  interrupt?: boolean(name='Interrupt'),
  invoker?: string(name='Invoker'),
  message?: string(name='Message'),
  pk?: string(name='Pk'),
  success?: boolean(name='Success'),
  taskExtraData?: string(name='TaskExtraData'),
  taskIdentifier?: string(name='TaskIdentifier'),
}

model CreatePhysicalDeleteResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: CreatePhysicalDeleteResponseBody(name='body'),
}

async function createPhysicalDeleteWithOptions(request: CreatePhysicalDeleteRequest, runtime: Util.RuntimeOptions): CreatePhysicalDeleteResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.bid)) {
    query['Bid'] = request.bid;
  }
  if (!Util.isUnset(request.country)) {
    query['Country'] = request.country;
  }
  if (!Util.isUnset(request.gmtWakeup)) {
    query['GmtWakeup'] = request.gmtWakeup;
  }
  if (!Util.isUnset(request.hid)) {
    query['Hid'] = request.hid;
  }
  if (!Util.isUnset(request.interrupt)) {
    query['Interrupt'] = request.interrupt;
  }
  if (!Util.isUnset(request.invoker)) {
    query['Invoker'] = request.invoker;
  }
  if (!Util.isUnset(request.message)) {
    query['Message'] = request.message;
  }
  if (!Util.isUnset(request.pk)) {
    query['Pk'] = request.pk;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.success)) {
    query['Success'] = request.success;
  }
  if (!Util.isUnset(request.taskExtraData)) {
    query['TaskExtraData'] = request.taskExtraData;
  }
  if (!Util.isUnset(request.taskIdentifier)) {
    query['TaskIdentifier'] = request.taskIdentifier;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CreatePhysicalDelete',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function createPhysicalDelete(request: CreatePhysicalDeleteRequest): CreatePhysicalDeleteResponse {
  var runtime = new Util.RuntimeOptions{};
  return createPhysicalDeleteWithOptions(request, runtime);
}

model CreatePoolInfoRequest {
  ownerId?: long(name='OwnerId'),
  poolName?: string(name='PoolName'),
  prodCode?: string(name='ProdCode'),
  resType?: int32(name='ResType'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
}

model CreatePoolInfoResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: string(name='data'),
}

model CreatePoolInfoResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: CreatePoolInfoResponseBody(name='body'),
}

async function createPoolInfoWithOptions(request: CreatePoolInfoRequest, runtime: Util.RuntimeOptions): CreatePoolInfoResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.poolName)) {
    query['PoolName'] = request.poolName;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.resType)) {
    query['ResType'] = request.resType;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CreatePoolInfo',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function createPoolInfo(request: CreatePoolInfoRequest): CreatePoolInfoResponse {
  var runtime = new Util.RuntimeOptions{};
  return createPoolInfoWithOptions(request, runtime);
}

model CreateProductRequest {
  ownerId?: long(name='OwnerId'),
  prodCode?: string(name='ProdCode'),
  prodId?: string(name='ProdId'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
}

model CreateProductResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: boolean(name='data'),
}

model CreateProductResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: CreateProductResponseBody(name='body'),
}

async function createProductWithOptions(request: CreateProductRequest, runtime: Util.RuntimeOptions): CreateProductResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.prodId)) {
    query['ProdId'] = request.prodId;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CreateProduct',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function createProduct(request: CreateProductRequest): CreateProductResponse {
  var runtime = new Util.RuntimeOptions{};
  return createProductWithOptions(request, runtime);
}

model CreateRingToneRequest {
  billId?: string(name='BillId'),
  fileKey?: string(name='FileKey'),
  ownerId?: long(name='OwnerId'),
  playType?: string(name='PlayType'),
  prodCode?: string(name='ProdCode'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
  ringName?: string(name='RingName'),
  tts?: string(name='Tts'),
}

model CreateRingToneResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: string(name='data'),
}

model CreateRingToneResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: CreateRingToneResponseBody(name='body'),
}

async function createRingToneWithOptions(request: CreateRingToneRequest, runtime: Util.RuntimeOptions): CreateRingToneResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.billId)) {
    query['BillId'] = request.billId;
  }
  if (!Util.isUnset(request.fileKey)) {
    query['FileKey'] = request.fileKey;
  }
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.playType)) {
    query['PlayType'] = request.playType;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  if (!Util.isUnset(request.ringName)) {
    query['RingName'] = request.ringName;
  }
  if (!Util.isUnset(request.tts)) {
    query['Tts'] = request.tts;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CreateRingTone',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function createRingTone(request: CreateRingToneRequest): CreateRingToneResponse {
  var runtime = new Util.RuntimeOptions{};
  return createRingToneWithOptions(request, runtime);
}

model CreateSubsTrialRequest {
  ownerId?: long(name='OwnerId'),
  phoneA?: string(name='PhoneA'),
  phoneB?: string(name='PhoneB'),
  prodCode?: string(name='ProdCode'),
  resType?: string(name='ResType'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
}

model CreateSubsTrialResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: boolean(name='data'),
}

model CreateSubsTrialResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: CreateSubsTrialResponseBody(name='body'),
}

async function createSubsTrialWithOptions(request: CreateSubsTrialRequest, runtime: Util.RuntimeOptions): CreateSubsTrialResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.phoneA)) {
    query['PhoneA'] = request.phoneA;
  }
  if (!Util.isUnset(request.phoneB)) {
    query['PhoneB'] = request.phoneB;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.resType)) {
    query['ResType'] = request.resType;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CreateSubsTrial',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function createSubsTrial(request: CreateSubsTrialRequest): CreateSubsTrialResponse {
  var runtime = new Util.RuntimeOptions{};
  return createSubsTrialWithOptions(request, runtime);
}

model CreateTransferRecordRequest {
  city?: string(name='City'),
  numberList?: string(name='NumberList'),
  originBillId?: string(name='OriginBillId'),
  originName?: string(name='OriginName'),
  ownerId?: long(name='OwnerId'),
  prodCode?: string(name='ProdCode'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
  targetBillId?: string(name='TargetBillId'),
  targetName?: string(name='TargetName'),
  total?: int32(name='Total'),
  transferType?: int32(name='TransferType'),
}

model CreateTransferRecordResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: string(name='data'),
}

model CreateTransferRecordResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: CreateTransferRecordResponseBody(name='body'),
}

async function createTransferRecordWithOptions(request: CreateTransferRecordRequest, runtime: Util.RuntimeOptions): CreateTransferRecordResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.city)) {
    query['City'] = request.city;
  }
  if (!Util.isUnset(request.numberList)) {
    query['NumberList'] = request.numberList;
  }
  if (!Util.isUnset(request.originBillId)) {
    query['OriginBillId'] = request.originBillId;
  }
  if (!Util.isUnset(request.originName)) {
    query['OriginName'] = request.originName;
  }
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  if (!Util.isUnset(request.targetBillId)) {
    query['TargetBillId'] = request.targetBillId;
  }
  if (!Util.isUnset(request.targetName)) {
    query['TargetName'] = request.targetName;
  }
  if (!Util.isUnset(request.total)) {
    query['Total'] = request.total;
  }
  if (!Util.isUnset(request.transferType)) {
    query['TransferType'] = request.transferType;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CreateTransferRecord',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function createTransferRecord(request: CreateTransferRecordRequest): CreateTransferRecordResponse {
  var runtime = new Util.RuntimeOptions{};
  return createTransferRecordWithOptions(request, runtime);
}

model DeleteCertifyInfoRequest {
  certifyId?: string(name='CertifyId'),
  ownerId?: long(name='OwnerId'),
  prodCode?: string(name='ProdCode'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
}

model DeleteCertifyInfoResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: string(name='data'),
}

model DeleteCertifyInfoResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: DeleteCertifyInfoResponseBody(name='body'),
}

async function deleteCertifyInfoWithOptions(request: DeleteCertifyInfoRequest, runtime: Util.RuntimeOptions): DeleteCertifyInfoResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.certifyId)) {
    query['CertifyId'] = request.certifyId;
  }
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DeleteCertifyInfo',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function deleteCertifyInfo(request: DeleteCertifyInfoRequest): DeleteCertifyInfoResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteCertifyInfoWithOptions(request, runtime);
}

model DeleteContactsRequest {
  billId?: string(name='BillId'),
  id?: long(name='Id'),
  ownerId?: long(name='OwnerId'),
  prodCode?: string(name='ProdCode'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
}

model DeleteContactsResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: string(name='data'),
}

model DeleteContactsResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: DeleteContactsResponseBody(name='body'),
}

async function deleteContactsWithOptions(request: DeleteContactsRequest, runtime: Util.RuntimeOptions): DeleteContactsResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.billId)) {
    query['BillId'] = request.billId;
  }
  if (!Util.isUnset(request.id)) {
    query['Id'] = request.id;
  }
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DeleteContacts',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function deleteContacts(request: DeleteContactsRequest): DeleteContactsResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteContactsWithOptions(request, runtime);
}

model DeleteGroupDetailRequest {
  groupId?: string(name='GroupId'),
  idList?: string(name='IdList'),
  ownerId?: long(name='OwnerId'),
  poolKey?: string(name='PoolKey'),
  prodCode?: string(name='ProdCode'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
}

model DeleteGroupDetailResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: boolean(name='data'),
}

model DeleteGroupDetailResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: DeleteGroupDetailResponseBody(name='body'),
}

async function deleteGroupDetailWithOptions(request: DeleteGroupDetailRequest, runtime: Util.RuntimeOptions): DeleteGroupDetailResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.groupId)) {
    query['GroupId'] = request.groupId;
  }
  if (!Util.isUnset(request.idList)) {
    query['IdList'] = request.idList;
  }
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.poolKey)) {
    query['PoolKey'] = request.poolKey;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DeleteGroupDetail',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function deleteGroupDetail(request: DeleteGroupDetailRequest): DeleteGroupDetailResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteGroupDetailWithOptions(request, runtime);
}

model DeleteMessageCallbackRequest {
  bizType?: string(name='BizType'),
  ownerId?: long(name='OwnerId'),
  prodCode?: string(name='ProdCode'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
}

model DeleteMessageCallbackResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: boolean(name='data'),
}

model DeleteMessageCallbackResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: DeleteMessageCallbackResponseBody(name='body'),
}

async function deleteMessageCallbackWithOptions(request: DeleteMessageCallbackRequest, runtime: Util.RuntimeOptions): DeleteMessageCallbackResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.bizType)) {
    query['BizType'] = request.bizType;
  }
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DeleteMessageCallback',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function deleteMessageCallback(request: DeleteMessageCallbackRequest): DeleteMessageCallbackResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteMessageCallbackWithOptions(request, runtime);
}

model DeleteRingToneRequest {
  billId?: string(name='BillId'),
  id?: string(name='Id'),
  ownerId?: long(name='OwnerId'),
  prodCode?: string(name='ProdCode'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
}

model DeleteRingToneResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: string(name='data'),
}

model DeleteRingToneResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: DeleteRingToneResponseBody(name='body'),
}

async function deleteRingToneWithOptions(request: DeleteRingToneRequest, runtime: Util.RuntimeOptions): DeleteRingToneResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.billId)) {
    query['BillId'] = request.billId;
  }
  if (!Util.isUnset(request.id)) {
    query['Id'] = request.id;
  }
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DeleteRingTone',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function deleteRingTone(request: DeleteRingToneRequest): DeleteRingToneResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteRingToneWithOptions(request, runtime);
}

model DownloadCompleteRequest {
  bizType?: string(name='BizType'),
  ownerId?: long(name='OwnerId'),
  prodCode?: string(name='ProdCode'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
}

model DownloadCompleteResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: string(name='data'),
}

model DownloadCompleteResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: DownloadCompleteResponseBody(name='body'),
}

async function downloadCompleteWithOptions(request: DownloadCompleteRequest, runtime: Util.RuntimeOptions): DownloadCompleteResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.bizType)) {
    query['BizType'] = request.bizType;
  }
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DownloadComplete',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function downloadComplete(request: DownloadCompleteRequest): DownloadCompleteResponse {
  var runtime = new Util.RuntimeOptions{};
  return downloadCompleteWithOptions(request, runtime);
}

model ExportResRequest {
  billId?: string(name='BillId'),
  ownerId?: long(name='OwnerId'),
  prodCode?: string(name='ProdCode'),
  resBindStatus?: int32(name='ResBindStatus'),
  resType?: int32(name='ResType'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
  secretNo?: string(name='SecretNo'),
}

model ExportResResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: string(name='data'),
}

model ExportResResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ExportResResponseBody(name='body'),
}

async function exportResWithOptions(request: ExportResRequest, runtime: Util.RuntimeOptions): ExportResResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.billId)) {
    query['BillId'] = request.billId;
  }
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.resBindStatus)) {
    query['ResBindStatus'] = request.resBindStatus;
  }
  if (!Util.isUnset(request.resType)) {
    query['ResType'] = request.resType;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  if (!Util.isUnset(request.secretNo)) {
    query['SecretNo'] = request.secretNo;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ExportRes',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function exportRes(request: ExportResRequest): ExportResResponse {
  var runtime = new Util.RuntimeOptions{};
  return exportResWithOptions(request, runtime);
}

model GetEinvoicePdfDataRequest {
  appCode?: string(name='AppCode'),
  customer?: {
    appCode?: string(name='AppCode'),
    customerId?: string(name='CustomerId'),
    customerSite?: string(name='CustomerSite'),
    customerSystem?: string(name='CustomerSystem'),
    encryptProps?: map[string]string(name='EncryptProps'),
    language?: string(name='Language'),
    sign?: string(name='Sign'),
    uuid?: string(name='Uuid'),
  }(name='Customer'),
  encryptProps?: map[string]string(name='EncryptProps'),
  invoiceCode?: string(name='InvoiceCode'),
  invoiceNo?: string(name='InvoiceNo'),
  language?: string(name='Language'),
  sign?: string(name='Sign'),
  uuid?: string(name='Uuid'),
}

model GetEinvoicePdfDataResponseBody = {
  errorCode?: string(name='ErrorCode'),
  errorMessage?: string(name='ErrorMessage'),
  isSuccess?: boolean(name='IsSuccess'),
  returnValue?: {
    appCode?: string(name='AppCode'),
    EInvoiceData?: [ int32 ](name='EInvoiceData'),
    encryptProps?: map[string]string(name='EncryptProps'),
    invoiceCode?: string(name='InvoiceCode'),
    invoiceNo?: string(name='InvoiceNo'),
    language?: string(name='Language'),
    sign?: string(name='Sign'),
    uuid?: string(name='Uuid'),
  }(name='ReturnValue'),
}

model GetEinvoicePdfDataResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetEinvoicePdfDataResponseBody(name='body'),
}

async function getEinvoicePdfDataWithOptions(request: GetEinvoicePdfDataRequest, runtime: Util.RuntimeOptions): GetEinvoicePdfDataResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.appCode)) {
    body['AppCode'] = request.appCode;
  }
  var bodyFlat : map[string]any = {};
  if (!Util.isUnset(request.customer)) {
    bodyFlat['Customer'] = request.customer;
  }
  if (!Util.isUnset(request.encryptProps)) {
    bodyFlat['EncryptProps'] = request.encryptProps;
  }
  if (!Util.isUnset(request.invoiceCode)) {
    body['InvoiceCode'] = request.invoiceCode;
  }
  if (!Util.isUnset(request.invoiceNo)) {
    body['InvoiceNo'] = request.invoiceNo;
  }
  if (!Util.isUnset(request.language)) {
    body['Language'] = request.language;
  }
  if (!Util.isUnset(request.sign)) {
    body['Sign'] = request.sign;
  }
  if (!Util.isUnset(request.uuid)) {
    body['Uuid'] = request.uuid;
  }
  body = {
    ...body,
    ...OpenApiUtil.query(bodyFlat),
  };

  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetEinvoicePdfData',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getEinvoicePdfData(request: GetEinvoicePdfDataRequest): GetEinvoicePdfDataResponse {
  var runtime = new Util.RuntimeOptions{};
  return getEinvoicePdfDataWithOptions(request, runtime);
}

model GetSecretAsrInfoRequest {
  callId?: string(name='CallId'),
  callTime?: string(name='CallTime'),
  poolKey?: string(name='PoolKey'),
  prodCode?: string(name='ProdCode'),
}

model GetSecretAsrInfoResponseBody = {
  code?: string(name='Code'),
  data?: [ 
    {
      channel?: string(name='Channel'),
      text?: string(name='Text'),
    }
  ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
}

model GetSecretAsrInfoResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetSecretAsrInfoResponseBody(name='body'),
}

async function getSecretAsrInfoWithOptions(request: GetSecretAsrInfoRequest, runtime: Util.RuntimeOptions): GetSecretAsrInfoResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.callId)) {
    query['CallId'] = request.callId;
  }
  if (!Util.isUnset(request.callTime)) {
    query['CallTime'] = request.callTime;
  }
  if (!Util.isUnset(request.poolKey)) {
    query['PoolKey'] = request.poolKey;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetSecretAsrInfo',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getSecretAsrInfo(request: GetSecretAsrInfoRequest): GetSecretAsrInfoResponse {
  var runtime = new Util.RuntimeOptions{};
  return getSecretAsrInfoWithOptions(request, runtime);
}

model GetUserResourceTagStatusRequest {
  ownerId?: long(name='OwnerId'),
  prodCode?: string(name='ProdCode'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
  resourceType?: int32(name='ResourceType'),
}

model GetUserResourceTagStatusResponseBody = {
  code?: string(name='Code'),
  data?: string(name='Data'),
  requestId?: string(name='RequestId'),
}

model GetUserResourceTagStatusResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetUserResourceTagStatusResponseBody(name='body'),
}

async function getUserResourceTagStatusWithOptions(request: GetUserResourceTagStatusRequest, runtime: Util.RuntimeOptions): GetUserResourceTagStatusResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  if (!Util.isUnset(request.resourceType)) {
    query['ResourceType'] = request.resourceType;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetUserResourceTagStatus',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getUserResourceTagStatus(request: GetUserResourceTagStatusRequest): GetUserResourceTagStatusResponse {
  var runtime = new Util.RuntimeOptions{};
  return getUserResourceTagStatusWithOptions(request, runtime);
}

model ListAsrLanguageModelsRequest {
  ownerId?: long(name='OwnerId'),
  prodCode?: string(name='ProdCode'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
}

model ListAsrLanguageModelsResponseBody = {
  code?: string(name='Code'),
  data?: string(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
}

model ListAsrLanguageModelsResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ListAsrLanguageModelsResponseBody(name='body'),
}

async function listAsrLanguageModelsWithOptions(request: ListAsrLanguageModelsRequest, runtime: Util.RuntimeOptions): ListAsrLanguageModelsResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ListAsrLanguageModels',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function listAsrLanguageModels(request: ListAsrLanguageModelsRequest): ListAsrLanguageModelsResponse {
  var runtime = new Util.RuntimeOptions{};
  return listAsrLanguageModelsWithOptions(request, runtime);
}

model LockResourceRequest {
  billId?: string(name='BillId'),
  ownerId?: long(name='OwnerId'),
  prodCode?: string(name='ProdCode'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
  secretNo?: string(name='SecretNo'),
}

model LockResourceResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: string(name='data'),
}

model LockResourceResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: LockResourceResponseBody(name='body'),
}

async function lockResourceWithOptions(request: LockResourceRequest, runtime: Util.RuntimeOptions): LockResourceResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.billId)) {
    query['BillId'] = request.billId;
  }
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  if (!Util.isUnset(request.secretNo)) {
    query['SecretNo'] = request.secretNo;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'LockResource',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function lockResource(request: LockResourceRequest): LockResourceResponse {
  var runtime = new Util.RuntimeOptions{};
  return lockResourceWithOptions(request, runtime);
}

model OccupySecretResRequest {
  city?: string(name='City'),
  isDisplayPool?: boolean(name='IsDisplayPool'),
  noLike?: string(name='NoLike'),
  orderDetailId?: long(name='OrderDetailId'),
  orderId?: long(name='OrderId'),
  ownerId?: long(name='OwnerId'),
  partnerKey?: string(name='PartnerKey'),
  prodCode?: string(name='ProdCode'),
  resType?: long(name='ResType'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
  secretNoType?: int32(name='SecretNoType'),
  totalCount?: int32(name='TotalCount'),
  secretNo?: string(name='secretNo'),
}

model OccupySecretResResponseBody = {
  code?: string(name='Code'),
  data?: boolean(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model OccupySecretResResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: OccupySecretResResponseBody(name='body'),
}

async function occupySecretResWithOptions(request: OccupySecretResRequest, runtime: Util.RuntimeOptions): OccupySecretResResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.city)) {
    query['City'] = request.city;
  }
  if (!Util.isUnset(request.isDisplayPool)) {
    query['IsDisplayPool'] = request.isDisplayPool;
  }
  if (!Util.isUnset(request.noLike)) {
    query['NoLike'] = request.noLike;
  }
  if (!Util.isUnset(request.orderDetailId)) {
    query['OrderDetailId'] = request.orderDetailId;
  }
  if (!Util.isUnset(request.orderId)) {
    query['OrderId'] = request.orderId;
  }
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.partnerKey)) {
    query['PartnerKey'] = request.partnerKey;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.resType)) {
    query['ResType'] = request.resType;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  if (!Util.isUnset(request.secretNoType)) {
    query['SecretNoType'] = request.secretNoType;
  }
  if (!Util.isUnset(request.totalCount)) {
    query['TotalCount'] = request.totalCount;
  }
  if (!Util.isUnset(request.secretNo)) {
    query['secretNo'] = request.secretNo;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'OccupySecretRes',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function occupySecretRes(request: OccupySecretResRequest): OccupySecretResResponse {
  var runtime = new Util.RuntimeOptions{};
  return occupySecretResWithOptions(request, runtime);
}

model OrderSucceededCallbackRequest {
  ownerId?: long(name='OwnerId'),
  prodCode?: string(name='ProdCode'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
  data?: string(name='data'),
}

model OrderSucceededCallbackResponseBody = {
  code?: string(name='Code'),
  data?: string(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: string(name='Success'),
  synchro?: string(name='Synchro'),
}

model OrderSucceededCallbackResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: OrderSucceededCallbackResponseBody(name='body'),
}

async function orderSucceededCallbackWithOptions(request: OrderSucceededCallbackRequest, runtime: Util.RuntimeOptions): OrderSucceededCallbackResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  if (!Util.isUnset(request.data)) {
    query['data'] = request.data;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'OrderSucceededCallback',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function orderSucceededCallback(request: OrderSucceededCallbackRequest): OrderSucceededCallbackResponse {
  var runtime = new Util.RuntimeOptions{};
  return orderSucceededCallbackWithOptions(request, runtime);
}

model PoolConfigRequest {
  billId?: string(name='BillId'),
  callbackType?: int32(name='CallbackType'),
  frozenDay?: int32(name='FrozenDay'),
  needAllCallRecords?: boolean(name='NeedAllCallRecords'),
  openSmsWhite?: boolean(name='OpenSmsWhite'),
  ownerId?: long(name='OwnerId'),
  poolWarningLimit?: int32(name='PoolWarningLimit'),
  prodCode?: string(name='ProdCode'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
  selectXMode?: string(name='SelectXMode'),
  smartSmsWhitelist?: string(name='SmartSmsWhitelist'),
  smsChannel?: string(name='SmsChannel'),
}

model PoolConfigResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: string(name='data'),
}

model PoolConfigResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: PoolConfigResponseBody(name='body'),
}

async function poolConfigWithOptions(request: PoolConfigRequest, runtime: Util.RuntimeOptions): PoolConfigResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.billId)) {
    query['BillId'] = request.billId;
  }
  if (!Util.isUnset(request.callbackType)) {
    query['CallbackType'] = request.callbackType;
  }
  if (!Util.isUnset(request.frozenDay)) {
    query['FrozenDay'] = request.frozenDay;
  }
  if (!Util.isUnset(request.needAllCallRecords)) {
    query['NeedAllCallRecords'] = request.needAllCallRecords;
  }
  if (!Util.isUnset(request.openSmsWhite)) {
    query['OpenSmsWhite'] = request.openSmsWhite;
  }
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.poolWarningLimit)) {
    query['PoolWarningLimit'] = request.poolWarningLimit;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  if (!Util.isUnset(request.selectXMode)) {
    query['SelectXMode'] = request.selectXMode;
  }
  if (!Util.isUnset(request.smartSmsWhitelist)) {
    query['SmartSmsWhitelist'] = request.smartSmsWhitelist;
  }
  if (!Util.isUnset(request.smsChannel)) {
    query['SmsChannel'] = request.smsChannel;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'PoolConfig',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function poolConfig(request: PoolConfigRequest): PoolConfigResponse {
  var runtime = new Util.RuntimeOptions{};
  return poolConfigWithOptions(request, runtime);
}

model PurchaseResourcesRequest {
  billId?: string(name='BillId'),
  buyNumber?: int32(name='BuyNumber'),
  isDisplayPool?: boolean(name='IsDisplayPool'),
  noLike?: string(name='NoLike'),
  ownerId?: long(name='OwnerId'),
  prodCode?: string(name='ProdCode'),
  regionName?: string(name='RegionName'),
  resType?: int32(name='ResType'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
  specId?: long(name='SpecId'),
  usageScenarios?: string(name='UsageScenarios'),
}

model PurchaseResourcesResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: string(name='data'),
}

model PurchaseResourcesResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: PurchaseResourcesResponseBody(name='body'),
}

async function purchaseResourcesWithOptions(request: PurchaseResourcesRequest, runtime: Util.RuntimeOptions): PurchaseResourcesResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.billId)) {
    query['BillId'] = request.billId;
  }
  if (!Util.isUnset(request.buyNumber)) {
    query['BuyNumber'] = request.buyNumber;
  }
  if (!Util.isUnset(request.isDisplayPool)) {
    query['IsDisplayPool'] = request.isDisplayPool;
  }
  if (!Util.isUnset(request.noLike)) {
    query['NoLike'] = request.noLike;
  }
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.regionName)) {
    query['RegionName'] = request.regionName;
  }
  if (!Util.isUnset(request.resType)) {
    query['ResType'] = request.resType;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  if (!Util.isUnset(request.specId)) {
    query['SpecId'] = request.specId;
  }
  if (!Util.isUnset(request.usageScenarios)) {
    query['UsageScenarios'] = request.usageScenarios;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'PurchaseResources',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function purchaseResources(request: PurchaseResourcesRequest): PurchaseResourcesResponse {
  var runtime = new Util.RuntimeOptions{};
  return purchaseResourcesWithOptions(request, runtime);
}

model QueryBindingDetailsRequest {
  billId?: string(name='BillId'),
  ownerId?: long(name='OwnerId'),
  pageNo?: int32(name='PageNo'),
  pageSize?: int32(name='PageSize'),
  phoneNoA?: string(name='PhoneNoA'),
  phoneNoB?: string(name='PhoneNoB'),
  prodCode?: string(name='ProdCode'),
  resType?: int32(name='ResType'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
  secretNo?: string(name='SecretNo'),
  subId?: string(name='SubId'),
}

model QueryBindingDetailsResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: string(name='data'),
}

model QueryBindingDetailsResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: QueryBindingDetailsResponseBody(name='body'),
}

async function queryBindingDetailsWithOptions(request: QueryBindingDetailsRequest, runtime: Util.RuntimeOptions): QueryBindingDetailsResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.billId)) {
    query['BillId'] = request.billId;
  }
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.pageNo)) {
    query['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.phoneNoA)) {
    query['PhoneNoA'] = request.phoneNoA;
  }
  if (!Util.isUnset(request.phoneNoB)) {
    query['PhoneNoB'] = request.phoneNoB;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.resType)) {
    query['ResType'] = request.resType;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  if (!Util.isUnset(request.secretNo)) {
    query['SecretNo'] = request.secretNo;
  }
  if (!Util.isUnset(request.subId)) {
    query['SubId'] = request.subId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'QueryBindingDetails',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryBindingDetails(request: QueryBindingDetailsRequest): QueryBindingDetailsResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryBindingDetailsWithOptions(request, runtime);
}

model QueryBlackListRequest {
  billId?: string(name='BillId'),
  blackPrefix?: string(name='BlackPrefix'),
  blackType?: string(name='BlackType'),
  ownerId?: long(name='OwnerId'),
  pageNo?: int32(name='PageNo'),
  pageSize?: int32(name='PageSize'),
  prodCode?: string(name='ProdCode'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
}

model QueryBlackListResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: string(name='data'),
  message?: string(name='message'),
}

model QueryBlackListResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: QueryBlackListResponseBody(name='body'),
}

async function queryBlackListWithOptions(request: QueryBlackListRequest, runtime: Util.RuntimeOptions): QueryBlackListResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.billId)) {
    query['BillId'] = request.billId;
  }
  if (!Util.isUnset(request.blackPrefix)) {
    query['BlackPrefix'] = request.blackPrefix;
  }
  if (!Util.isUnset(request.blackType)) {
    query['BlackType'] = request.blackType;
  }
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.pageNo)) {
    query['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'QueryBlackList',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryBlackList(request: QueryBlackListRequest): QueryBlackListResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryBlackListWithOptions(request, runtime);
}

model QueryBuyPageInitDataRequest {
  ownerId?: long(name='OwnerId'),
  prodCode?: string(name='ProdCode'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
}

model QueryBuyPageInitDataResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: string(name='data'),
}

model QueryBuyPageInitDataResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: QueryBuyPageInitDataResponseBody(name='body'),
}

async function queryBuyPageInitDataWithOptions(request: QueryBuyPageInitDataRequest, runtime: Util.RuntimeOptions): QueryBuyPageInitDataResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'QueryBuyPageInitData',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryBuyPageInitData(request: QueryBuyPageInitDataRequest): QueryBuyPageInitDataResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryBuyPageInitDataWithOptions(request, runtime);
}

model QueryBuyPageResCountRequest {
  city?: string(name='City'),
  like?: string(name='Like'),
  ownerId?: long(name='OwnerId'),
  prodCode?: string(name='ProdCode'),
  resType?: int32(name='ResType'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
  specId?: long(name='SpecId'),
}

model QueryBuyPageResCountResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: string(name='data'),
}

model QueryBuyPageResCountResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: QueryBuyPageResCountResponseBody(name='body'),
}

async function queryBuyPageResCountWithOptions(request: QueryBuyPageResCountRequest, runtime: Util.RuntimeOptions): QueryBuyPageResCountResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.city)) {
    query['City'] = request.city;
  }
  if (!Util.isUnset(request.like)) {
    query['Like'] = request.like;
  }
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.resType)) {
    query['ResType'] = request.resType;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  if (!Util.isUnset(request.specId)) {
    query['SpecId'] = request.specId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'QueryBuyPageResCount',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryBuyPageResCount(request: QueryBuyPageResCountRequest): QueryBuyPageResCountResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryBuyPageResCountWithOptions(request, runtime);
}

model QueryBuyPageResInfoRequest {
  like?: string(name='Like'),
  ownerId?: long(name='OwnerId'),
  prodCode?: string(name='ProdCode'),
  resType?: int32(name='ResType'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
  specId?: long(name='SpecId'),
}

model QueryBuyPageResInfoResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: string(name='data'),
}

model QueryBuyPageResInfoResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: QueryBuyPageResInfoResponseBody(name='body'),
}

async function queryBuyPageResInfoWithOptions(request: QueryBuyPageResInfoRequest, runtime: Util.RuntimeOptions): QueryBuyPageResInfoResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.like)) {
    query['Like'] = request.like;
  }
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.resType)) {
    query['ResType'] = request.resType;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  if (!Util.isUnset(request.specId)) {
    query['SpecId'] = request.specId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'QueryBuyPageResInfo',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryBuyPageResInfo(request: QueryBuyPageResInfoRequest): QueryBuyPageResInfoResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryBuyPageResInfoWithOptions(request, runtime);
}

model QueryBuyResInfoRequest {
  like?: string(name='Like'),
  ownerId?: long(name='OwnerId'),
  prodCode?: string(name='ProdCode'),
  resType?: int32(name='ResType'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
  specId?: long(name='SpecId'),
}

model QueryBuyResInfoResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: string(name='data'),
}

model QueryBuyResInfoResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: QueryBuyResInfoResponseBody(name='body'),
}

async function queryBuyResInfoWithOptions(request: QueryBuyResInfoRequest, runtime: Util.RuntimeOptions): QueryBuyResInfoResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.like)) {
    query['Like'] = request.like;
  }
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.resType)) {
    query['ResType'] = request.resType;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  if (!Util.isUnset(request.specId)) {
    query['SpecId'] = request.specId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'QueryBuyResInfo',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryBuyResInfo(request: QueryBuyResInfoRequest): QueryBuyResInfoResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryBuyResInfoWithOptions(request, runtime);
}

model QueryCallRecordingListRequest {
  billId?: string(name='BillId'),
  callDate?: string(name='CallDate'),
  callId?: string(name='CallId'),
  ownerId?: long(name='OwnerId'),
  pageNo?: int32(name='PageNo'),
  pageSize?: int32(name='PageSize'),
  phoneNoA?: string(name='PhoneNoA'),
  phoneNoB?: string(name='PhoneNoB'),
  prodCode?: string(name='ProdCode'),
  resType?: int32(name='ResType'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
  secretNo?: string(name='SecretNo'),
}

model QueryCallRecordingListResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: string(name='data'),
}

model QueryCallRecordingListResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: QueryCallRecordingListResponseBody(name='body'),
}

async function queryCallRecordingListWithOptions(request: QueryCallRecordingListRequest, runtime: Util.RuntimeOptions): QueryCallRecordingListResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.billId)) {
    query['BillId'] = request.billId;
  }
  if (!Util.isUnset(request.callDate)) {
    query['CallDate'] = request.callDate;
  }
  if (!Util.isUnset(request.callId)) {
    query['CallId'] = request.callId;
  }
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.pageNo)) {
    query['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.phoneNoA)) {
    query['PhoneNoA'] = request.phoneNoA;
  }
  if (!Util.isUnset(request.phoneNoB)) {
    query['PhoneNoB'] = request.phoneNoB;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.resType)) {
    query['ResType'] = request.resType;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  if (!Util.isUnset(request.secretNo)) {
    query['SecretNo'] = request.secretNo;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'QueryCallRecordingList',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryCallRecordingList(request: QueryCallRecordingListRequest): QueryCallRecordingListResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryCallRecordingListWithOptions(request, runtime);
}

model QueryCertifyInfoListRequest {
  certifyStatus?: string(name='CertifyStatus'),
  ownerId?: long(name='OwnerId'),
  pageNo?: int32(name='PageNo'),
  pageSize?: int32(name='PageSize'),
  phoneNo?: string(name='PhoneNo'),
  prodCode?: string(name='ProdCode'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
}

model QueryCertifyInfoListResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: string(name='data'),
}

model QueryCertifyInfoListResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: QueryCertifyInfoListResponseBody(name='body'),
}

async function queryCertifyInfoListWithOptions(request: QueryCertifyInfoListRequest, runtime: Util.RuntimeOptions): QueryCertifyInfoListResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.certifyStatus)) {
    query['CertifyStatus'] = request.certifyStatus;
  }
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.pageNo)) {
    query['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.phoneNo)) {
    query['PhoneNo'] = request.phoneNo;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'QueryCertifyInfoList',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryCertifyInfoList(request: QueryCertifyInfoListRequest): QueryCertifyInfoListResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryCertifyInfoListWithOptions(request, runtime);
}

model QueryCertifyOverviewInfoRequest {
  ownerId?: long(name='OwnerId'),
  prodCode?: string(name='ProdCode'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
}

model QueryCertifyOverviewInfoResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: string(name='data'),
}

model QueryCertifyOverviewInfoResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: QueryCertifyOverviewInfoResponseBody(name='body'),
}

async function queryCertifyOverviewInfoWithOptions(request: QueryCertifyOverviewInfoRequest, runtime: Util.RuntimeOptions): QueryCertifyOverviewInfoResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'QueryCertifyOverviewInfo',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryCertifyOverviewInfo(request: QueryCertifyOverviewInfoRequest): QueryCertifyOverviewInfoResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryCertifyOverviewInfoWithOptions(request, runtime);
}

model QueryContactsListRequest {
  billId?: string(name='BillId'),
  ownerId?: long(name='OwnerId'),
  prodCode?: string(name='ProdCode'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
}

model QueryContactsListResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: string(name='data'),
}

model QueryContactsListResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: QueryContactsListResponseBody(name='body'),
}

async function queryContactsListWithOptions(request: QueryContactsListRequest, runtime: Util.RuntimeOptions): QueryContactsListResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.billId)) {
    query['BillId'] = request.billId;
  }
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'QueryContactsList',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryContactsList(request: QueryContactsListRequest): QueryContactsListResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryContactsListWithOptions(request, runtime);
}

model QueryCustInfoRequest {
  ownerId?: long(name='OwnerId'),
  prodCode?: string(name='ProdCode'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
}

model QueryCustInfoResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: {
    certifyType?: int32(name='CertifyType'),
    contactPhone?: string(name='ContactPhone'),
    custId?: long(name='CustId'),
    custName?: string(name='CustName'),
    isDayuCustomer?: boolean(name='IsDayuCustomer'),
    osStatus?: int32(name='OsStatus'),
    partnerId?: long(name='PartnerId'),
    userTag?: long(name='UserTag'),
    userTag2?: long(name='UserTag2'),
  }(name='data'),
}

model QueryCustInfoResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: QueryCustInfoResponseBody(name='body'),
}

async function queryCustInfoWithOptions(request: QueryCustInfoRequest, runtime: Util.RuntimeOptions): QueryCustInfoResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'QueryCustInfo',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryCustInfo(request: QueryCustInfoRequest): QueryCustInfoResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryCustInfoWithOptions(request, runtime);
}

model QueryDownloadUrlRequest {
  bizType?: string(name='BizType'),
  ownerId?: long(name='OwnerId'),
  prodCode?: string(name='ProdCode'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
}

model QueryDownloadUrlResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: string(name='data'),
}

model QueryDownloadUrlResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: QueryDownloadUrlResponseBody(name='body'),
}

async function queryDownloadUrlWithOptions(request: QueryDownloadUrlRequest, runtime: Util.RuntimeOptions): QueryDownloadUrlResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.bizType)) {
    query['BizType'] = request.bizType;
  }
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'QueryDownloadUrl',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryDownloadUrl(request: QueryDownloadUrlRequest): QueryDownloadUrlResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryDownloadUrlWithOptions(request, runtime);
}

model QueryEffectiveInvoiceListByBillNosRequest {
  appCode?: string(name='AppCode'),
  billNo?: string(name='BillNo'),
  encryptProps?: map[string]string(name='EncryptProps'),
  language?: string(name='Language'),
  majorBillNo?: string(name='MajorBillNo'),
  ouCode?: string(name='OuCode'),
  relatedSystem?: string(name='RelatedSystem'),
  sign?: string(name='Sign'),
  uuid?: string(name='Uuid'),
}

model QueryEffectiveInvoiceListByBillNosResponseBody = {
  errorCode?: string(name='ErrorCode'),
  errorMessage?: string(name='ErrorMessage'),
  isSuccess?: boolean(name='IsSuccess'),
  returnValue?: {
    encryptProps?: map[string]string(name='EncryptProps'),
    list?: [ 
      {
        aliCompany?: string(name='AliCompany'),
        aliId?: long(name='AliId'),
        amount?: double(name='Amount'),
        appCode?: string(name='AppCode'),
        buildAmount?: double(name='BuildAmount'),
        category?: string(name='Category'),
        encryptProps?: map[string]string(name='EncryptProps'),
        invoiceNo?: string(name='InvoiceNo'),
        invoiceStatus?: string(name='InvoiceStatus'),
        invoiceTitle?: string(name='InvoiceTitle'),
        language?: string(name='Language'),
        orderItemNo?: string(name='OrderItemNo'),
        parentContractNo?: string(name='ParentContractNo'),
        sign?: string(name='Sign'),
        site?: string(name='Site'),
        taxRegisgerNo?: string(name='TaxRegisgerNo'),
        uuid?: string(name='Uuid'),
      }
    ](name='List'),
    sign?: string(name='Sign'),
  }(name='ReturnValue'),
}

model QueryEffectiveInvoiceListByBillNosResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: QueryEffectiveInvoiceListByBillNosResponseBody(name='body'),
}

async function queryEffectiveInvoiceListByBillNosWithOptions(request: QueryEffectiveInvoiceListByBillNosRequest, runtime: Util.RuntimeOptions): QueryEffectiveInvoiceListByBillNosResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.appCode)) {
    body['AppCode'] = request.appCode;
  }
  if (!Util.isUnset(request.billNo)) {
    body['BillNo'] = request.billNo;
  }
  var bodyFlat : map[string]any = {};
  if (!Util.isUnset(request.encryptProps)) {
    bodyFlat['EncryptProps'] = request.encryptProps;
  }
  if (!Util.isUnset(request.language)) {
    body['Language'] = request.language;
  }
  if (!Util.isUnset(request.majorBillNo)) {
    body['MajorBillNo'] = request.majorBillNo;
  }
  if (!Util.isUnset(request.ouCode)) {
    body['OuCode'] = request.ouCode;
  }
  if (!Util.isUnset(request.relatedSystem)) {
    body['RelatedSystem'] = request.relatedSystem;
  }
  if (!Util.isUnset(request.sign)) {
    body['Sign'] = request.sign;
  }
  if (!Util.isUnset(request.uuid)) {
    body['Uuid'] = request.uuid;
  }
  body = {
    ...body,
    ...OpenApiUtil.query(bodyFlat),
  };

  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'QueryEffectiveInvoiceListByBillNos',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryEffectiveInvoiceListByBillNos(request: QueryEffectiveInvoiceListByBillNosRequest): QueryEffectiveInvoiceListByBillNosResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryEffectiveInvoiceListByBillNosWithOptions(request, runtime);
}

model QueryExportResUrlRequest {
  billId?: string(name='BillId'),
  ownerId?: long(name='OwnerId'),
  prodCode?: string(name='ProdCode'),
  resType?: int32(name='ResType'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
  taskId?: string(name='TaskId'),
}

model QueryExportResUrlResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: string(name='data'),
}

model QueryExportResUrlResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: QueryExportResUrlResponseBody(name='body'),
}

async function queryExportResUrlWithOptions(request: QueryExportResUrlRequest, runtime: Util.RuntimeOptions): QueryExportResUrlResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.billId)) {
    query['BillId'] = request.billId;
  }
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.resType)) {
    query['ResType'] = request.resType;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  if (!Util.isUnset(request.taskId)) {
    query['TaskId'] = request.taskId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'QueryExportResUrl',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryExportResUrl(request: QueryExportResUrlRequest): QueryExportResUrlResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryExportResUrlWithOptions(request, runtime);
}

model QueryGroupDetailListRequest {
  groupId?: string(name='GroupId'),
  number?: string(name='Number'),
  ownerId?: long(name='OwnerId'),
  pageNo?: string(name='PageNo'),
  pageSize?: string(name='PageSize'),
  poolKey?: string(name='PoolKey'),
  prodCode?: string(name='ProdCode'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
}

model QueryGroupDetailListResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: boolean(name='data'),
}

model QueryGroupDetailListResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: QueryGroupDetailListResponseBody(name='body'),
}

async function queryGroupDetailListWithOptions(request: QueryGroupDetailListRequest, runtime: Util.RuntimeOptions): QueryGroupDetailListResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.groupId)) {
    query['GroupId'] = request.groupId;
  }
  if (!Util.isUnset(request.number)) {
    query['Number'] = request.number;
  }
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.pageNo)) {
    query['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.poolKey)) {
    query['PoolKey'] = request.poolKey;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'QueryGroupDetailList',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryGroupDetailList(request: QueryGroupDetailListRequest): QueryGroupDetailListResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryGroupDetailListWithOptions(request, runtime);
}

model QueryGroupInfoListRequest {
  ownerId?: long(name='OwnerId'),
  pageNo?: string(name='PageNo'),
  pageSize?: string(name='PageSize'),
  poolKey?: string(name='PoolKey'),
  prodCode?: string(name='ProdCode'),
  queryKey?: string(name='QueryKey'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
}

model QueryGroupInfoListResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: boolean(name='data'),
}

model QueryGroupInfoListResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: QueryGroupInfoListResponseBody(name='body'),
}

async function queryGroupInfoListWithOptions(request: QueryGroupInfoListRequest, runtime: Util.RuntimeOptions): QueryGroupInfoListResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.pageNo)) {
    query['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.poolKey)) {
    query['PoolKey'] = request.poolKey;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.queryKey)) {
    query['QueryKey'] = request.queryKey;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'QueryGroupInfoList',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryGroupInfoList(request: QueryGroupInfoListRequest): QueryGroupInfoListResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryGroupInfoListWithOptions(request, runtime);
}

model QueryInvoiceInfoByRequestNoRequest {
  appCode?: string(name='AppCode'),
  encryptProps?: map[string]string(name='EncryptProps'),
  language?: string(name='Language'),
  relatedSystem?: string(name='RelatedSystem'),
  requestNo?: string(name='RequestNo'),
  sign?: string(name='Sign'),
  uuid?: string(name='Uuid'),
}

model QueryInvoiceInfoByRequestNoResponseBody = {
  errorCode?: string(name='ErrorCode'),
  errorMessage?: string(name='ErrorMessage'),
  isSuccess?: boolean(name='IsSuccess'),
  returnValue?: {
    encryptProps?: map[string]string(name='EncryptProps'),
    list?: [ 
      {
        amount?: double(name='Amount'),
        appCode?: string(name='AppCode'),
        currencyCode?: string(name='CurrencyCode'),
        customer?: {
          appCode?: string(name='AppCode'),
          customerId?: string(name='CustomerId'),
          customerSite?: string(name='CustomerSite'),
          customerSystem?: string(name='CustomerSystem'),
          encryptProps?: map[string]string(name='EncryptProps'),
          language?: string(name='Language'),
          sign?: string(name='Sign'),
          uuid?: string(name='Uuid'),
        }(name='Customer'),
        detailList?: [ 
          {
            amount?: double(name='Amount'),
            appCode?: string(name='AppCode'),
            cargoName?: string(name='CargoName'),
            discountAmount?: double(name='DiscountAmount'),
            discountTaxAmount?: double(name='DiscountTaxAmount'),
            encryptProps?: map[string]string(name='EncryptProps'),
            excludingTaxAmount?: double(name='ExcludingTaxAmount'),
            excludingTaxDiscountAmount?: double(name='ExcludingTaxDiscountAmount'),
            excludingTaxRedAmount?: double(name='ExcludingTaxRedAmount'),
            excludingTaxRemainAmount?: double(name='ExcludingTaxRemainAmount'),
            excludingTaxUnitPrice?: double(name='ExcludingTaxUnitPrice'),
            invoiceDetailId?: long(name='InvoiceDetailId'),
            language?: string(name='Language'),
            model?: string(name='Model'),
            quantity?: double(name='Quantity'),
            quantityUnit?: string(name='QuantityUnit'),
            redAmount?: double(name='RedAmount'),
            relatedId?: string(name='RelatedId'),
            remainAmount?: double(name='RemainAmount'),
            sign?: string(name='Sign'),
            sourceList?: [ 
              {
                amount?: double(name='Amount'),
                appCode?: string(name='AppCode'),
                billAmount?: double(name='BillAmount'),
                billDomain?: string(name='BillDomain'),
                billNo?: string(name='BillNo'),
                billType?: string(name='BillType'),
                blueSourceId?: long(name='BlueSourceId'),
                canMerge?: boolean(name='CanMerge'),
                cargoName?: string(name='CargoName'),
                category?: string(name='Category'),
                companyName?: string(name='CompanyName'),
                currencyCode?: string(name='CurrencyCode'),
                customer?: {
                  appCode?: string(name='AppCode'),
                  customerId?: string(name='CustomerId'),
                  customerSite?: string(name='CustomerSite'),
                  customerSystem?: string(name='CustomerSystem'),
                  encryptProps?: map[string]string(name='EncryptProps'),
                  language?: string(name='Language'),
                  sign?: string(name='Sign'),
                  uuid?: string(name='Uuid'),
                }(name='Customer'),
                discountAmount?: double(name='DiscountAmount'),
                discountTaxAmount?: double(name='DiscountTaxAmount'),
                encryptProps?: map[string]string(name='EncryptProps'),
                excludingTaxAmount?: double(name='ExcludingTaxAmount'),
                excludingTaxDiscountAmount?: double(name='ExcludingTaxDiscountAmount'),
                excludingTaxRedAmount?: double(name='ExcludingTaxRedAmount'),
                excludingTaxRemainAmount?: double(name='ExcludingTaxRemainAmount'),
                gmtBill?: string(name='GmtBill'),
                gmtBillEnd?: string(name='GmtBillEnd'),
                gmtBillStart?: string(name='GmtBillStart'),
                gmtBuild?: string(name='GmtBuild'),
                isApply?: string(name='IsApply'),
                language?: string(name='Language'),
                majorBillNo?: string(name='MajorBillNo'),
                model?: string(name='Model'),
                ouCode?: string(name='OuCode'),
                parentCategory?: string(name='ParentCategory'),
                productDomain?: string(name='ProductDomain'),
                productId?: string(name='ProductId'),
                productName?: string(name='ProductName'),
                quantity?: double(name='Quantity'),
                quantityUnit?: string(name='QuantityUnit'),
                redAmount?: double(name='RedAmount'),
                relatedId?: string(name='RelatedId'),
                remainAmount?: double(name='RemainAmount'),
                revenueType?: string(name='RevenueType'),
                serviceName?: string(name='ServiceName'),
                sign?: string(name='Sign'),
                siteId?: string(name='SiteId'),
                sourceId?: long(name='SourceId'),
                taxAmount?: double(name='TaxAmount'),
                taxRate?: double(name='TaxRate'),
                unitPrice?: double(name='UnitPrice'),
                uuid?: string(name='Uuid'),
              }
            ](name='SourceList'),
            taxAmount?: double(name='TaxAmount'),
            taxRate?: double(name='TaxRate'),
            unitPrice?: double(name='UnitPrice'),
            uuid?: string(name='Uuid'),
          }
        ](name='DetailList'),
        encryptProps?: map[string]string(name='EncryptProps'),
        excludingTaxAmount?: double(name='ExcludingTaxAmount'),
        excludingTaxRedAmount?: double(name='ExcludingTaxRedAmount'),
        excludingTaxRemainAmount?: double(name='ExcludingTaxRemainAmount'),
        invoiceCode?: string(name='InvoiceCode'),
        invoiceDate?: string(name='InvoiceDate'),
        invoiceId?: long(name='InvoiceId'),
        invoiceNo?: string(name='InvoiceNo'),
        invoiceStatus?: string(name='InvoiceStatus'),
        invoiceType?: string(name='InvoiceType'),
        isRed?: boolean(name='IsRed'),
        isReissue?: boolean(name='IsReissue'),
        language?: string(name='Language'),
        linkInvoiceCode?: string(name='LinkInvoiceCode'),
        linkInvoiceNo?: string(name='LinkInvoiceNo'),
        logisticsInfo?: {
          appCode?: string(name='AppCode'),
          customer?: {
            appCode?: string(name='AppCode'),
            customerId?: string(name='CustomerId'),
            customerSite?: string(name='CustomerSite'),
            customerSystem?: string(name='CustomerSystem'),
            encryptProps?: map[string]string(name='EncryptProps'),
            language?: string(name='Language'),
            sign?: string(name='Sign'),
            uuid?: string(name='Uuid'),
          }(name='Customer'),
          encryptProps?: map[string]string(name='EncryptProps'),
          gmtSend?: string(name='GmtSend'),
          invoiceCode?: string(name='InvoiceCode'),
          invoiceDate?: string(name='InvoiceDate'),
          invoiceId?: long(name='InvoiceId'),
          invoiceNo?: string(name='InvoiceNo'),
          invoiceNos?: string(name='InvoiceNos'),
          language?: string(name='Language'),
          logisticsCompanies?: string(name='LogisticsCompanies'),
          relatedId?: string(name='RelatedId'),
          sender?: string(name='Sender'),
          sign?: string(name='Sign'),
          timestamp?: long(name='Timestamp'),
          trackingNumber?: string(name='TrackingNumber'),
          uuid?: string(name='Uuid'),
        }(name='LogisticsInfo'),
        materialType?: string(name='MaterialType'),
        memo?: string(name='Memo'),
        ouCode?: string(name='OuCode'),
        purchaserBankInfo?: string(name='PurchaserBankInfo'),
        purchaserContactInfo?: string(name='PurchaserContactInfo'),
        purchaserName?: string(name='PurchaserName'),
        purchaserTaxNo?: string(name='PurchaserTaxNo'),
        redAmount?: double(name='RedAmount'),
        relatedId?: string(name='RelatedId'),
        remainAmount?: double(name='RemainAmount'),
        sign?: string(name='Sign'),
        siteId?: string(name='SiteId'),
        taxAmount?: double(name='TaxAmount'),
        uuid?: string(name='Uuid'),
      }
    ](name='List'),
    sign?: string(name='Sign'),
  }(name='ReturnValue'),
}

model QueryInvoiceInfoByRequestNoResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: QueryInvoiceInfoByRequestNoResponseBody(name='body'),
}

async function queryInvoiceInfoByRequestNoWithOptions(request: QueryInvoiceInfoByRequestNoRequest, runtime: Util.RuntimeOptions): QueryInvoiceInfoByRequestNoResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.appCode)) {
    body['AppCode'] = request.appCode;
  }
  var bodyFlat : map[string]any = {};
  if (!Util.isUnset(request.encryptProps)) {
    bodyFlat['EncryptProps'] = request.encryptProps;
  }
  if (!Util.isUnset(request.language)) {
    body['Language'] = request.language;
  }
  if (!Util.isUnset(request.relatedSystem)) {
    body['RelatedSystem'] = request.relatedSystem;
  }
  if (!Util.isUnset(request.requestNo)) {
    body['RequestNo'] = request.requestNo;
  }
  if (!Util.isUnset(request.sign)) {
    body['Sign'] = request.sign;
  }
  if (!Util.isUnset(request.uuid)) {
    body['Uuid'] = request.uuid;
  }
  body = {
    ...body,
    ...OpenApiUtil.query(bodyFlat),
  };

  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'QueryInvoiceInfoByRequestNo',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryInvoiceInfoByRequestNo(request: QueryInvoiceInfoByRequestNoRequest): QueryInvoiceInfoByRequestNoResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryInvoiceInfoByRequestNoWithOptions(request, runtime);
}

model QueryMessageCallbackInfoRequest {
  bizType?: string(name='BizType'),
  ownerId?: long(name='OwnerId'),
  prodCode?: string(name='ProdCode'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
}

model QueryMessageCallbackInfoResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: boolean(name='data'),
}

model QueryMessageCallbackInfoResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: QueryMessageCallbackInfoResponseBody(name='body'),
}

async function queryMessageCallbackInfoWithOptions(request: QueryMessageCallbackInfoRequest, runtime: Util.RuntimeOptions): QueryMessageCallbackInfoResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.bizType)) {
    query['BizType'] = request.bizType;
  }
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'QueryMessageCallbackInfo',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryMessageCallbackInfo(request: QueryMessageCallbackInfoRequest): QueryMessageCallbackInfoResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryMessageCallbackInfoWithOptions(request, runtime);
}

model QueryMessageQueueListRequest {
  bizType?: string(name='BizType'),
  ownerId?: long(name='OwnerId'),
  prodCode?: string(name='ProdCode'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
}

model QueryMessageQueueListResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: string(name='data'),
}

model QueryMessageQueueListResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: QueryMessageQueueListResponseBody(name='body'),
}

async function queryMessageQueueListWithOptions(request: QueryMessageQueueListRequest, runtime: Util.RuntimeOptions): QueryMessageQueueListResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.bizType)) {
    query['BizType'] = request.bizType;
  }
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'QueryMessageQueueList',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryMessageQueueList(request: QueryMessageQueueListRequest): QueryMessageQueueListResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryMessageQueueListWithOptions(request, runtime);
}

model QueryMonthlyBillInfoRequest {
  billCycle?: string(name='BillCycle'),
  itemId?: string(name='ItemId'),
  itemName?: string(name='ItemName'),
  ownerId?: long(name='OwnerId'),
  prodCode?: string(name='ProdCode'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
  subjectItemId?: string(name='SubjectItemId'),
}

model QueryMonthlyBillInfoResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: string(name='data'),
}

model QueryMonthlyBillInfoResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: QueryMonthlyBillInfoResponseBody(name='body'),
}

async function queryMonthlyBillInfoWithOptions(request: QueryMonthlyBillInfoRequest, runtime: Util.RuntimeOptions): QueryMonthlyBillInfoResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.billCycle)) {
    query['BillCycle'] = request.billCycle;
  }
  if (!Util.isUnset(request.itemId)) {
    query['ItemId'] = request.itemId;
  }
  if (!Util.isUnset(request.itemName)) {
    query['ItemName'] = request.itemName;
  }
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  if (!Util.isUnset(request.subjectItemId)) {
    query['SubjectItemId'] = request.subjectItemId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'QueryMonthlyBillInfo',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryMonthlyBillInfo(request: QueryMonthlyBillInfoRequest): QueryMonthlyBillInfoResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryMonthlyBillInfoWithOptions(request, runtime);
}

model QueryMonthlyStatisticsInfoRequest {
  billId?: string(name='BillId'),
  endDate?: string(name='EndDate'),
  ownerId?: long(name='OwnerId'),
  prodCode?: string(name='ProdCode'),
  resType?: int32(name='ResType'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
  startDate?: string(name='StartDate'),
}

model QueryMonthlyStatisticsInfoResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: string(name='data'),
}

model QueryMonthlyStatisticsInfoResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: QueryMonthlyStatisticsInfoResponseBody(name='body'),
}

async function queryMonthlyStatisticsInfoWithOptions(request: QueryMonthlyStatisticsInfoRequest, runtime: Util.RuntimeOptions): QueryMonthlyStatisticsInfoResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.billId)) {
    query['BillId'] = request.billId;
  }
  if (!Util.isUnset(request.endDate)) {
    query['EndDate'] = request.endDate;
  }
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.resType)) {
    query['ResType'] = request.resType;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  if (!Util.isUnset(request.startDate)) {
    query['StartDate'] = request.startDate;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'QueryMonthlyStatisticsInfo',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryMonthlyStatisticsInfo(request: QueryMonthlyStatisticsInfoRequest): QueryMonthlyStatisticsInfoResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryMonthlyStatisticsInfoWithOptions(request, runtime);
}

model QueryNoBuyTasksRequest {
  billId?: string(name='BillId'),
  ownerId?: long(name='OwnerId'),
  pageNo?: int32(name='PageNo'),
  pageSize?: int32(name='PageSize'),
  prodCode?: string(name='ProdCode'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
}

model QueryNoBuyTasksResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: string(name='data'),
  message?: string(name='message'),
}

model QueryNoBuyTasksResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: QueryNoBuyTasksResponseBody(name='body'),
}

async function queryNoBuyTasksWithOptions(request: QueryNoBuyTasksRequest, runtime: Util.RuntimeOptions): QueryNoBuyTasksResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.billId)) {
    query['BillId'] = request.billId;
  }
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.pageNo)) {
    query['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'QueryNoBuyTasks',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryNoBuyTasks(request: QueryNoBuyTasksRequest): QueryNoBuyTasksResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryNoBuyTasksWithOptions(request, runtime);
}

model QueryNoDistributeRequest {
  billId?: string(name='BillId'),
  ownerId?: long(name='OwnerId'),
  prodCode?: string(name='ProdCode'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
}

model QueryNoDistributeResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: string(name='data'),
}

model QueryNoDistributeResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: QueryNoDistributeResponseBody(name='body'),
}

async function queryNoDistributeWithOptions(request: QueryNoDistributeRequest, runtime: Util.RuntimeOptions): QueryNoDistributeResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.billId)) {
    query['BillId'] = request.billId;
  }
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'QueryNoDistribute',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryNoDistribute(request: QueryNoDistributeRequest): QueryNoDistributeResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryNoDistributeWithOptions(request, runtime);
}

model QueryOpenStatusRequest {
  busOffer?: long(name='BusOffer'),
  ownerId?: long(name='OwnerId'),
  prodCode?: string(name='ProdCode'),
  prodId?: string(name='ProdId'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
}

model QueryOpenStatusResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: boolean(name='data'),
}

model QueryOpenStatusResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: QueryOpenStatusResponseBody(name='body'),
}

async function queryOpenStatusWithOptions(request: QueryOpenStatusRequest, runtime: Util.RuntimeOptions): QueryOpenStatusResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.busOffer)) {
    query['BusOffer'] = request.busOffer;
  }
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.prodId)) {
    query['ProdId'] = request.prodId;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'QueryOpenStatus',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryOpenStatus(request: QueryOpenStatusRequest): QueryOpenStatusResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryOpenStatusWithOptions(request, runtime);
}

model QueryPackageDetailRequest {
  ownerId?: long(name='OwnerId'),
  pageNo?: int32(name='PageNo'),
  pageSize?: int32(name='PageSize'),
  prodCode?: string(name='ProdCode'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
  status?: string(name='Status'),
}

model QueryPackageDetailResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: string(name='data'),
}

model QueryPackageDetailResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: QueryPackageDetailResponseBody(name='body'),
}

async function queryPackageDetailWithOptions(request: QueryPackageDetailRequest, runtime: Util.RuntimeOptions): QueryPackageDetailResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.pageNo)) {
    query['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  if (!Util.isUnset(request.status)) {
    query['Status'] = request.status;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'QueryPackageDetail',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryPackageDetail(request: QueryPackageDetailRequest): QueryPackageDetailResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryPackageDetailWithOptions(request, runtime);
}

model QueryPackageListRequest {
  billCycle?: string(name='BillCycle'),
  ownerId?: long(name='OwnerId'),
  prodCode?: string(name='ProdCode'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
}

model QueryPackageListResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: string(name='data'),
}

model QueryPackageListResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: QueryPackageListResponseBody(name='body'),
}

async function queryPackageListWithOptions(request: QueryPackageListRequest, runtime: Util.RuntimeOptions): QueryPackageListResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.billCycle)) {
    query['BillCycle'] = request.billCycle;
  }
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'QueryPackageList',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryPackageList(request: QueryPackageListRequest): QueryPackageListResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryPackageListWithOptions(request, runtime);
}

model QueryPackageStatisticsRequest {
  ownerId?: long(name='OwnerId'),
  prodCode?: string(name='ProdCode'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
}

model QueryPackageStatisticsResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: string(name='data'),
}

model QueryPackageStatisticsResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: QueryPackageStatisticsResponseBody(name='body'),
}

async function queryPackageStatisticsWithOptions(request: QueryPackageStatisticsRequest, runtime: Util.RuntimeOptions): QueryPackageStatisticsResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'QueryPackageStatistics',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryPackageStatistics(request: QueryPackageStatisticsRequest): QueryPackageStatisticsResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryPackageStatisticsWithOptions(request, runtime);
}

model QueryPoolCityListRequest {
  billId?: string(name='BillId'),
  ownerId?: long(name='OwnerId'),
  prodCode?: string(name='ProdCode'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
}

model QueryPoolCityListResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: string(name='data'),
}

model QueryPoolCityListResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: QueryPoolCityListResponseBody(name='body'),
}

async function queryPoolCityListWithOptions(request: QueryPoolCityListRequest, runtime: Util.RuntimeOptions): QueryPoolCityListResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.billId)) {
    query['BillId'] = request.billId;
  }
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'QueryPoolCityList',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryPoolCityList(request: QueryPoolCityListRequest): QueryPoolCityListResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryPoolCityListWithOptions(request, runtime);
}

model QueryPoolInfoListRequest {
  isFuzzyQuery?: boolean(name='IsFuzzyQuery'),
  ownerId?: long(name='OwnerId'),
  pageNo?: string(name='PageNo'),
  pageSize?: string(name='PageSize'),
  poolName?: string(name='PoolName'),
  prodCode?: string(name='ProdCode'),
  resType?: int32(name='ResType'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
  searchParam?: string(name='SearchParam'),
}

model QueryPoolInfoListResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: string(name='data'),
}

model QueryPoolInfoListResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: QueryPoolInfoListResponseBody(name='body'),
}

async function queryPoolInfoListWithOptions(request: QueryPoolInfoListRequest, runtime: Util.RuntimeOptions): QueryPoolInfoListResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.isFuzzyQuery)) {
    query['IsFuzzyQuery'] = request.isFuzzyQuery;
  }
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.pageNo)) {
    query['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.poolName)) {
    query['PoolName'] = request.poolName;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.resType)) {
    query['ResType'] = request.resType;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  if (!Util.isUnset(request.searchParam)) {
    query['SearchParam'] = request.searchParam;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'QueryPoolInfoList',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryPoolInfoList(request: QueryPoolInfoListRequest): QueryPoolInfoListResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryPoolInfoListWithOptions(request, runtime);
}

model QueryPoolMonthlyBillInfoRequest {
  billCycle?: string(name='BillCycle'),
  billId?: string(name='BillId'),
  ownerId?: long(name='OwnerId'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
}

model QueryPoolMonthlyBillInfoResponseBody = {
  code?: string(name='Code'),
  data?: string(name='Data'),
  requestId?: string(name='RequestId'),
}

model QueryPoolMonthlyBillInfoResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: QueryPoolMonthlyBillInfoResponseBody(name='body'),
}

async function queryPoolMonthlyBillInfoWithOptions(request: QueryPoolMonthlyBillInfoRequest, runtime: Util.RuntimeOptions): QueryPoolMonthlyBillInfoResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.billCycle)) {
    query['BillCycle'] = request.billCycle;
  }
  if (!Util.isUnset(request.billId)) {
    query['BillId'] = request.billId;
  }
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'QueryPoolMonthlyBillInfo',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryPoolMonthlyBillInfo(request: QueryPoolMonthlyBillInfoRequest): QueryPoolMonthlyBillInfoResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryPoolMonthlyBillInfoWithOptions(request, runtime);
}

model QueryPoolStatisticsInfoRequest {
  ownerId?: long(name='OwnerId'),
  prodCode?: string(name='ProdCode'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
}

model QueryPoolStatisticsInfoResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: string(name='data'),
}

model QueryPoolStatisticsInfoResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: QueryPoolStatisticsInfoResponseBody(name='body'),
}

async function queryPoolStatisticsInfoWithOptions(request: QueryPoolStatisticsInfoRequest, runtime: Util.RuntimeOptions): QueryPoolStatisticsInfoResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'QueryPoolStatisticsInfo',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryPoolStatisticsInfo(request: QueryPoolStatisticsInfoRequest): QueryPoolStatisticsInfoResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryPoolStatisticsInfoWithOptions(request, runtime);
}

model QueryPoolSummaryInfoRequest {
  ownerId?: long(name='OwnerId'),
  prodCode?: string(name='ProdCode'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
}

model QueryPoolSummaryInfoResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: string(name='data'),
}

model QueryPoolSummaryInfoResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: QueryPoolSummaryInfoResponseBody(name='body'),
}

async function queryPoolSummaryInfoWithOptions(request: QueryPoolSummaryInfoRequest, runtime: Util.RuntimeOptions): QueryPoolSummaryInfoResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'QueryPoolSummaryInfo',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryPoolSummaryInfo(request: QueryPoolSummaryInfoRequest): QueryPoolSummaryInfoResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryPoolSummaryInfoWithOptions(request, runtime);
}

model QueryPurchasedInfoRequest {
  billId?: string(name='BillId'),
  ownerId?: long(name='OwnerId'),
  prodCode?: string(name='ProdCode'),
  resType?: int32(name='ResType'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
}

model QueryPurchasedInfoResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: string(name='data'),
}

model QueryPurchasedInfoResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: QueryPurchasedInfoResponseBody(name='body'),
}

async function queryPurchasedInfoWithOptions(request: QueryPurchasedInfoRequest, runtime: Util.RuntimeOptions): QueryPurchasedInfoResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.billId)) {
    query['BillId'] = request.billId;
  }
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.resType)) {
    query['ResType'] = request.resType;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'QueryPurchasedInfo',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryPurchasedInfo(request: QueryPurchasedInfoRequest): QueryPurchasedInfoResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryPurchasedInfoWithOptions(request, runtime);
}

model QueryPurchasedResListRequest {
  billId?: string(name='BillId'),
  city?: string(name='City'),
  isDisplayPool?: boolean(name='IsDisplayPool'),
  ownerId?: long(name='OwnerId'),
  pageNo?: int32(name='PageNo'),
  pageSize?: int32(name='PageSize'),
  prodCode?: string(name='ProdCode'),
  resBindStatus?: int32(name='ResBindStatus'),
  resType?: int32(name='ResType'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
  secretNo?: string(name='SecretNo'),
}

model QueryPurchasedResListResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: string(name='data'),
}

model QueryPurchasedResListResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: QueryPurchasedResListResponseBody(name='body'),
}

async function queryPurchasedResListWithOptions(request: QueryPurchasedResListRequest, runtime: Util.RuntimeOptions): QueryPurchasedResListResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.billId)) {
    query['BillId'] = request.billId;
  }
  if (!Util.isUnset(request.city)) {
    query['City'] = request.city;
  }
  if (!Util.isUnset(request.isDisplayPool)) {
    query['IsDisplayPool'] = request.isDisplayPool;
  }
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.pageNo)) {
    query['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.resBindStatus)) {
    query['ResBindStatus'] = request.resBindStatus;
  }
  if (!Util.isUnset(request.resType)) {
    query['ResType'] = request.resType;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  if (!Util.isUnset(request.secretNo)) {
    query['SecretNo'] = request.secretNo;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'QueryPurchasedResList',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryPurchasedResList(request: QueryPurchasedResListRequest): QueryPurchasedResListResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryPurchasedResListWithOptions(request, runtime);
}

model QueryQRCodeInfoRequest {
  ownerId?: long(name='OwnerId'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
  secretNumber?: string(name='SecretNumber'),
}

model QueryQRCodeInfoResponseBody = {
  code?: string(name='Code'),
  httpStatusCode?: int32(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
  token?: string(name='Token'),
}

model QueryQRCodeInfoResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: QueryQRCodeInfoResponseBody(name='body'),
}

async function queryQRCodeInfoWithOptions(request: QueryQRCodeInfoRequest, runtime: Util.RuntimeOptions): QueryQRCodeInfoResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  if (!Util.isUnset(request.secretNumber)) {
    query['SecretNumber'] = request.secretNumber;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'QueryQRCodeInfo',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryQRCodeInfo(request: QueryQRCodeInfoRequest): QueryQRCodeInfoResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryQRCodeInfoWithOptions(request, runtime);
}

model QueryRecordingUrlRequest {
  billId?: string(name='BillId'),
  callDate?: string(name='CallDate'),
  callId?: string(name='CallId'),
  ownerId?: long(name='OwnerId'),
  prodCode?: string(name='ProdCode'),
  resType?: int32(name='ResType'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
}

model QueryRecordingUrlResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: string(name='data'),
}

model QueryRecordingUrlResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: QueryRecordingUrlResponseBody(name='body'),
}

async function queryRecordingUrlWithOptions(request: QueryRecordingUrlRequest, runtime: Util.RuntimeOptions): QueryRecordingUrlResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.billId)) {
    query['BillId'] = request.billId;
  }
  if (!Util.isUnset(request.callDate)) {
    query['CallDate'] = request.callDate;
  }
  if (!Util.isUnset(request.callId)) {
    query['CallId'] = request.callId;
  }
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.resType)) {
    query['ResType'] = request.resType;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'QueryRecordingUrl',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryRecordingUrl(request: QueryRecordingUrlRequest): QueryRecordingUrlResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryRecordingUrlWithOptions(request, runtime);
}

model QueryResSummaryInfoRequest {
  ownerId?: long(name='OwnerId'),
  prodCode?: string(name='ProdCode'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
}

model QueryResSummaryInfoResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: string(name='data'),
}

model QueryResSummaryInfoResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: QueryResSummaryInfoResponseBody(name='body'),
}

async function queryResSummaryInfoWithOptions(request: QueryResSummaryInfoRequest, runtime: Util.RuntimeOptions): QueryResSummaryInfoResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'QueryResSummaryInfo',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryResSummaryInfo(request: QueryResSummaryInfoRequest): QueryResSummaryInfoResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryResSummaryInfoWithOptions(request, runtime);
}

model QueryRingToneUrlRequest {
  billId?: string(name='BillId'),
  fileKey?: string(name='FileKey'),
  ownerId?: long(name='OwnerId'),
  prodCode?: string(name='ProdCode'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
}

model QueryRingToneUrlResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: string(name='data'),
}

model QueryRingToneUrlResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: QueryRingToneUrlResponseBody(name='body'),
}

async function queryRingToneUrlWithOptions(request: QueryRingToneUrlRequest, runtime: Util.RuntimeOptions): QueryRingToneUrlResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.billId)) {
    query['BillId'] = request.billId;
  }
  if (!Util.isUnset(request.fileKey)) {
    query['FileKey'] = request.fileKey;
  }
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'QueryRingToneUrl',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryRingToneUrl(request: QueryRingToneUrlRequest): QueryRingToneUrlResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryRingToneUrlWithOptions(request, runtime);
}

model QueryRingTonesRequest {
  billId?: string(name='BillId'),
  ownerId?: long(name='OwnerId'),
  pageNo?: int32(name='PageNo'),
  pageSize?: int32(name='PageSize'),
  playType?: string(name='PlayType'),
  prodCode?: string(name='ProdCode'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
}

model QueryRingTonesResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: string(name='data'),
}

model QueryRingTonesResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: QueryRingTonesResponseBody(name='body'),
}

async function queryRingTonesWithOptions(request: QueryRingTonesRequest, runtime: Util.RuntimeOptions): QueryRingTonesResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.billId)) {
    query['BillId'] = request.billId;
  }
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.pageNo)) {
    query['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.playType)) {
    query['PlayType'] = request.playType;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'QueryRingTones',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryRingTones(request: QueryRingTonesRequest): QueryRingTonesResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryRingTonesWithOptions(request, runtime);
}

model QuerySimplePoolInfoListRequest {
  ownerId?: long(name='OwnerId'),
  poolName?: string(name='PoolName'),
  prodCode?: string(name='ProdCode'),
  resType?: int32(name='ResType'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
}

model QuerySimplePoolInfoListResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: string(name='data'),
}

model QuerySimplePoolInfoListResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: QuerySimplePoolInfoListResponseBody(name='body'),
}

async function querySimplePoolInfoListWithOptions(request: QuerySimplePoolInfoListRequest, runtime: Util.RuntimeOptions): QuerySimplePoolInfoListResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.poolName)) {
    query['PoolName'] = request.poolName;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.resType)) {
    query['ResType'] = request.resType;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'QuerySimplePoolInfoList',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function querySimplePoolInfoList(request: QuerySimplePoolInfoListRequest): QuerySimplePoolInfoListResponse {
  var runtime = new Util.RuntimeOptions{};
  return querySimplePoolInfoListWithOptions(request, runtime);
}

model QueryStatisticsInfoRequest {
  billId?: string(name='BillId'),
  endDate?: string(name='EndDate'),
  ownerId?: long(name='OwnerId'),
  pageNo?: int32(name='PageNo'),
  pageSize?: int32(name='PageSize'),
  prodCode?: string(name='ProdCode'),
  resType?: int32(name='ResType'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
  startDate?: string(name='StartDate'),
}

model QueryStatisticsInfoResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: string(name='data'),
}

model QueryStatisticsInfoResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: QueryStatisticsInfoResponseBody(name='body'),
}

async function queryStatisticsInfoWithOptions(request: QueryStatisticsInfoRequest, runtime: Util.RuntimeOptions): QueryStatisticsInfoResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.billId)) {
    query['BillId'] = request.billId;
  }
  if (!Util.isUnset(request.endDate)) {
    query['EndDate'] = request.endDate;
  }
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.pageNo)) {
    query['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.resType)) {
    query['ResType'] = request.resType;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  if (!Util.isUnset(request.startDate)) {
    query['StartDate'] = request.startDate;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'QueryStatisticsInfo',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryStatisticsInfo(request: QueryStatisticsInfoRequest): QueryStatisticsInfoResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryStatisticsInfoWithOptions(request, runtime);
}

model QueryTagOpenStatusRequest {
  attributeKey?: string(name='AttributeKey'),
  bizType?: int32(name='BizType'),
  ownerId?: long(name='OwnerId'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
  subAttributeKey?: string(name='SubAttributeKey'),
}

model QueryTagOpenStatusResponseBody = {
  code?: string(name='Code'),
  data?: boolean(name='Data'),
  requestId?: string(name='RequestId'),
}

model QueryTagOpenStatusResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: QueryTagOpenStatusResponseBody(name='body'),
}

async function queryTagOpenStatusWithOptions(request: QueryTagOpenStatusRequest, runtime: Util.RuntimeOptions): QueryTagOpenStatusResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.attributeKey)) {
    query['AttributeKey'] = request.attributeKey;
  }
  if (!Util.isUnset(request.bizType)) {
    query['BizType'] = request.bizType;
  }
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  if (!Util.isUnset(request.subAttributeKey)) {
    query['SubAttributeKey'] = request.subAttributeKey;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'QueryTagOpenStatus',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryTagOpenStatus(request: QueryTagOpenStatusRequest): QueryTagOpenStatusResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryTagOpenStatusWithOptions(request, runtime);
}

model QueryTransferDetailsRequest {
  ownerId?: long(name='OwnerId'),
  pageNo?: int32(name='PageNo'),
  pageSize?: int32(name='PageSize'),
  prodCode?: string(name='ProdCode'),
  recordId?: long(name='RecordId'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
}

model QueryTransferDetailsResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: string(name='data'),
}

model QueryTransferDetailsResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: QueryTransferDetailsResponseBody(name='body'),
}

async function queryTransferDetailsWithOptions(request: QueryTransferDetailsRequest, runtime: Util.RuntimeOptions): QueryTransferDetailsResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.pageNo)) {
    query['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.recordId)) {
    query['RecordId'] = request.recordId;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'QueryTransferDetails',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryTransferDetails(request: QueryTransferDetailsRequest): QueryTransferDetailsResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryTransferDetailsWithOptions(request, runtime);
}

model QueryTransferRecordRequest {
  ownerId?: long(name='OwnerId'),
  prodCode?: string(name='ProdCode'),
  recordId?: long(name='RecordId'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
}

model QueryTransferRecordResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: string(name='data'),
}

model QueryTransferRecordResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: QueryTransferRecordResponseBody(name='body'),
}

async function queryTransferRecordWithOptions(request: QueryTransferRecordRequest, runtime: Util.RuntimeOptions): QueryTransferRecordResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.recordId)) {
    query['RecordId'] = request.recordId;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'QueryTransferRecord',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryTransferRecord(request: QueryTransferRecordRequest): QueryTransferRecordResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryTransferRecordWithOptions(request, runtime);
}

model QueryTransferRecordsRequest {
  ownerId?: long(name='OwnerId'),
  pageNo?: int32(name='PageNo'),
  pageSize?: int32(name='PageSize'),
  prodCode?: string(name='ProdCode'),
  recordId?: long(name='RecordId'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
}

model QueryTransferRecordsResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: string(name='data'),
}

model QueryTransferRecordsResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: QueryTransferRecordsResponseBody(name='body'),
}

async function queryTransferRecordsWithOptions(request: QueryTransferRecordsRequest, runtime: Util.RuntimeOptions): QueryTransferRecordsResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.pageNo)) {
    query['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.recordId)) {
    query['RecordId'] = request.recordId;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'QueryTransferRecords',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryTransferRecords(request: QueryTransferRecordsRequest): QueryTransferRecordsResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryTransferRecordsWithOptions(request, runtime);
}

model QueryUserDeleteStatusRequest {
  bid?: string(name='Bid'),
  country?: string(name='Country'),
  gmtWakeup?: string(name='GmtWakeup'),
  hid?: long(name='Hid'),
  interrupt?: boolean(name='Interrupt'),
  invoker?: string(name='Invoker'),
  level?: long(name='Level'),
  message?: string(name='Message'),
  pk?: string(name='Pk'),
  prodCode?: string(name='ProdCode'),
  prompt?: string(name='Prompt'),
  success?: boolean(name='Success'),
  taskExtraData?: string(name='TaskExtraData'),
  taskIdentifier?: string(name='TaskIdentifier'),
  url?: string(name='Url'),
}

model QueryUserDeleteStatusResponseBody = {
  bid?: string(name='Bid'),
  country?: string(name='Country'),
  gmtWakeup?: string(name='GmtWakeup'),
  hid?: long(name='Hid'),
  interrupt?: boolean(name='Interrupt'),
  invoker?: string(name='Invoker'),
  level?: long(name='Level'),
  message?: string(name='Message'),
  pk?: string(name='Pk'),
  prompt?: string(name='Prompt'),
  success?: boolean(name='Success'),
  taskExtraData?: string(name='TaskExtraData'),
  taskIdentifier?: string(name='TaskIdentifier'),
  url?: string(name='Url'),
}

model QueryUserDeleteStatusResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: QueryUserDeleteStatusResponseBody(name='body'),
}

async function queryUserDeleteStatusWithOptions(request: QueryUserDeleteStatusRequest, runtime: Util.RuntimeOptions): QueryUserDeleteStatusResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.bid)) {
    query['Bid'] = request.bid;
  }
  if (!Util.isUnset(request.country)) {
    query['Country'] = request.country;
  }
  if (!Util.isUnset(request.gmtWakeup)) {
    query['GmtWakeup'] = request.gmtWakeup;
  }
  if (!Util.isUnset(request.hid)) {
    query['Hid'] = request.hid;
  }
  if (!Util.isUnset(request.interrupt)) {
    query['Interrupt'] = request.interrupt;
  }
  if (!Util.isUnset(request.invoker)) {
    query['Invoker'] = request.invoker;
  }
  if (!Util.isUnset(request.level)) {
    query['Level'] = request.level;
  }
  if (!Util.isUnset(request.message)) {
    query['Message'] = request.message;
  }
  if (!Util.isUnset(request.pk)) {
    query['Pk'] = request.pk;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.prompt)) {
    query['Prompt'] = request.prompt;
  }
  if (!Util.isUnset(request.success)) {
    query['Success'] = request.success;
  }
  if (!Util.isUnset(request.taskExtraData)) {
    query['TaskExtraData'] = request.taskExtraData;
  }
  if (!Util.isUnset(request.taskIdentifier)) {
    query['TaskIdentifier'] = request.taskIdentifier;
  }
  if (!Util.isUnset(request.url)) {
    query['Url'] = request.url;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'QueryUserDeleteStatus',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryUserDeleteStatus(request: QueryUserDeleteStatusRequest): QueryUserDeleteStatusResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryUserDeleteStatusWithOptions(request, runtime);
}

model QueryUserInfoRequest {
  ownerId?: long(name='OwnerId'),
  prodCode?: string(name='ProdCode'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
}

model QueryUserInfoResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: string(name='data'),
}

model QueryUserInfoResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: QueryUserInfoResponseBody(name='body'),
}

async function queryUserInfoWithOptions(request: QueryUserInfoRequest, runtime: Util.RuntimeOptions): QueryUserInfoResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'QueryUserInfo',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryUserInfo(request: QueryUserInfoRequest): QueryUserInfoResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryUserInfoWithOptions(request, runtime);
}

model QueryUserResPoolInfoRequest {
  ownerId?: long(name='OwnerId'),
  prodCode?: string(name='ProdCode'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
}

model QueryUserResPoolInfoResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: string(name='data'),
}

model QueryUserResPoolInfoResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: QueryUserResPoolInfoResponseBody(name='body'),
}

async function queryUserResPoolInfoWithOptions(request: QueryUserResPoolInfoRequest, runtime: Util.RuntimeOptions): QueryUserResPoolInfoResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'QueryUserResPoolInfo',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryUserResPoolInfo(request: QueryUserResPoolInfoRequest): QueryUserResPoolInfoResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryUserResPoolInfoWithOptions(request, runtime);
}

model QueryVirtualOperationShowRequest {
  ownerId?: long(name='OwnerId'),
  prodCode?: string(name='ProdCode'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
}

model QueryVirtualOperationShowResponseBody = {
  code?: string(name='Code'),
  data?: string(name='Data'),
  requestId?: string(name='RequestId'),
}

model QueryVirtualOperationShowResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: QueryVirtualOperationShowResponseBody(name='body'),
}

async function queryVirtualOperationShowWithOptions(request: QueryVirtualOperationShowRequest, runtime: Util.RuntimeOptions): QueryVirtualOperationShowResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'QueryVirtualOperationShow',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryVirtualOperationShow(request: QueryVirtualOperationShowRequest): QueryVirtualOperationShowResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryVirtualOperationShowWithOptions(request, runtime);
}

model QueryWarningListRequest {
  ownerId?: long(name='OwnerId'),
  prodCode?: string(name='ProdCode'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
}

model QueryWarningListResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: string(name='data'),
}

model QueryWarningListResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: QueryWarningListResponseBody(name='body'),
}

async function queryWarningListWithOptions(request: QueryWarningListRequest, runtime: Util.RuntimeOptions): QueryWarningListResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'QueryWarningList',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryWarningList(request: QueryWarningListRequest): QueryWarningListResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryWarningListWithOptions(request, runtime);
}

model QueryWaybillOrderInfoRequest {
  outerOrderCode?: string(name='OuterOrderCode'),
  ownerId?: long(name='OwnerId'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
}

model QueryWaybillOrderInfoResponseBody = {
  code?: string(name='Code'),
  data?: {
    aliyunprice?: string(name='Aliyunprice'),
    appointGotEndTime?: string(name='AppointGotEndTime'),
    appointGotStartTime?: string(name='AppointGotStartTime'),
    bizType?: int32(name='BizType'),
    city?: string(name='City'),
    cpCode?: string(name='CpCode'),
    gotCode?: string(name='GotCode'),
    lastLogisticDetail?: string(name='LastLogisticDetail'),
    logisticsGmtModified?: string(name='LogisticsGmtModified'),
    logisticsStatus?: string(name='LogisticsStatus'),
    logisticsStatusDesc?: string(name='LogisticsStatusDesc'),
    mailNo?: string(name='MailNo'),
    outerOrderCode?: string(name='OuterOrderCode'),
  }(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
}

model QueryWaybillOrderInfoResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: QueryWaybillOrderInfoResponseBody(name='body'),
}

async function queryWaybillOrderInfoWithOptions(request: QueryWaybillOrderInfoRequest, runtime: Util.RuntimeOptions): QueryWaybillOrderInfoResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.outerOrderCode)) {
    query['OuterOrderCode'] = request.outerOrderCode;
  }
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'QueryWaybillOrderInfo',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryWaybillOrderInfo(request: QueryWaybillOrderInfoRequest): QueryWaybillOrderInfoResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryWaybillOrderInfoWithOptions(request, runtime);
}

model QueryWaybillOrderStatisticsInfoRequest {
  endTime?: string(name='EndTime'),
  granularity?: string(name='Granularity'),
  ownerId?: long(name='OwnerId'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
  startTime?: string(name='StartTime'),
}

model QueryWaybillOrderStatisticsInfoResponseBody = {
  code?: string(name='Code'),
  data?: [ 
    {
      aliyunpriceAmount?: double(name='AliyunpriceAmount'),
      cancelCount?: int32(name='CancelCount'),
      gmtCreate?: string(name='GmtCreate'),
      gotCount?: int32(name='GotCount'),
      orderTotal?: int32(name='OrderTotal'),
    }
  ](name='Data'),
  httpStatusCode?: string(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model QueryWaybillOrderStatisticsInfoResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: QueryWaybillOrderStatisticsInfoResponseBody(name='body'),
}

async function queryWaybillOrderStatisticsInfoWithOptions(request: QueryWaybillOrderStatisticsInfoRequest, runtime: Util.RuntimeOptions): QueryWaybillOrderStatisticsInfoResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.endTime)) {
    query['EndTime'] = request.endTime;
  }
  if (!Util.isUnset(request.granularity)) {
    query['Granularity'] = request.granularity;
  }
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  if (!Util.isUnset(request.startTime)) {
    query['StartTime'] = request.startTime;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'QueryWaybillOrderStatisticsInfo',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryWaybillOrderStatisticsInfo(request: QueryWaybillOrderStatisticsInfoRequest): QueryWaybillOrderStatisticsInfoResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryWaybillOrderStatisticsInfoWithOptions(request, runtime);
}

model ReleaseResourceRequest {
  billId?: string(name='BillId'),
  isDisplayPool?: boolean(name='IsDisplayPool'),
  ownerId?: long(name='OwnerId'),
  prodCode?: string(name='ProdCode'),
  resType?: int32(name='ResType'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
  secretNo?: string(name='SecretNo'),
}

model ReleaseResourceResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: string(name='data'),
}

model ReleaseResourceResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ReleaseResourceResponseBody(name='body'),
}

async function releaseResourceWithOptions(request: ReleaseResourceRequest, runtime: Util.RuntimeOptions): ReleaseResourceResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.billId)) {
    query['BillId'] = request.billId;
  }
  if (!Util.isUnset(request.isDisplayPool)) {
    query['IsDisplayPool'] = request.isDisplayPool;
  }
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.resType)) {
    query['ResType'] = request.resType;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  if (!Util.isUnset(request.secretNo)) {
    query['SecretNo'] = request.secretNo;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ReleaseResource',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function releaseResource(request: ReleaseResourceRequest): ReleaseResourceResponse {
  var runtime = new Util.RuntimeOptions{};
  return releaseResourceWithOptions(request, runtime);
}

model TestTtsRingToneRequest {
  billId?: string(name='BillId'),
  ownerId?: long(name='OwnerId'),
  prodCode?: string(name='ProdCode'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
  tts?: string(name='Tts'),
  voiceSpeed?: string(name='VoiceSpeed'),
  voiceStyle?: string(name='VoiceStyle'),
  voiceType?: string(name='VoiceType'),
  voiceVolume?: string(name='VoiceVolume'),
}

model TestTtsRingToneResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: string(name='data'),
}

model TestTtsRingToneResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: TestTtsRingToneResponseBody(name='body'),
}

async function testTtsRingToneWithOptions(request: TestTtsRingToneRequest, runtime: Util.RuntimeOptions): TestTtsRingToneResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.billId)) {
    query['BillId'] = request.billId;
  }
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  if (!Util.isUnset(request.tts)) {
    query['Tts'] = request.tts;
  }
  if (!Util.isUnset(request.voiceSpeed)) {
    query['VoiceSpeed'] = request.voiceSpeed;
  }
  if (!Util.isUnset(request.voiceStyle)) {
    query['VoiceStyle'] = request.voiceStyle;
  }
  if (!Util.isUnset(request.voiceType)) {
    query['VoiceType'] = request.voiceType;
  }
  if (!Util.isUnset(request.voiceVolume)) {
    query['VoiceVolume'] = request.voiceVolume;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'TestTtsRingTone',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function testTtsRingTone(request: TestTtsRingToneRequest): TestTtsRingToneResponse {
  var runtime = new Util.RuntimeOptions{};
  return testTtsRingToneWithOptions(request, runtime);
}

model UnbindResourceRequest {
  billId?: string(name='BillId'),
  bindIds?: string(name='BindIds'),
  ownerId?: long(name='OwnerId'),
  prodCode?: string(name='ProdCode'),
  resType?: int32(name='ResType'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
  secretNo?: string(name='SecretNo'),
}

model UnbindResourceResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: string(name='data'),
}

model UnbindResourceResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: UnbindResourceResponseBody(name='body'),
}

async function unbindResourceWithOptions(request: UnbindResourceRequest, runtime: Util.RuntimeOptions): UnbindResourceResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.billId)) {
    query['BillId'] = request.billId;
  }
  if (!Util.isUnset(request.bindIds)) {
    query['BindIds'] = request.bindIds;
  }
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.resType)) {
    query['ResType'] = request.resType;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  if (!Util.isUnset(request.secretNo)) {
    query['SecretNo'] = request.secretNo;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UnbindResource',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function unbindResource(request: UnbindResourceRequest): UnbindResourceResponse {
  var runtime = new Util.RuntimeOptions{};
  return unbindResourceWithOptions(request, runtime);
}

model UnlockResourceRequest {
  billId?: string(name='BillId'),
  ownerId?: long(name='OwnerId'),
  prodCode?: string(name='ProdCode'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
  secretNo?: string(name='SecretNo'),
}

model UnlockResourceResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: string(name='data'),
}

model UnlockResourceResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: UnlockResourceResponseBody(name='body'),
}

async function unlockResourceWithOptions(request: UnlockResourceRequest, runtime: Util.RuntimeOptions): UnlockResourceResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.billId)) {
    query['BillId'] = request.billId;
  }
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  if (!Util.isUnset(request.secretNo)) {
    query['SecretNo'] = request.secretNo;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UnlockResource',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function unlockResource(request: UnlockResourceRequest): UnlockResourceResponse {
  var runtime = new Util.RuntimeOptions{};
  return unlockResourceWithOptions(request, runtime);
}

model UpdateContactsRequest {
  billId?: string(name='BillId'),
  id?: long(name='Id'),
  name?: string(name='Name'),
  ownerId?: long(name='OwnerId'),
  phoneNumber?: string(name='PhoneNumber'),
  prodCode?: string(name='ProdCode'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
}

model UpdateContactsResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: string(name='data'),
}

model UpdateContactsResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: UpdateContactsResponseBody(name='body'),
}

async function updateContactsWithOptions(request: UpdateContactsRequest, runtime: Util.RuntimeOptions): UpdateContactsResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.billId)) {
    query['BillId'] = request.billId;
  }
  if (!Util.isUnset(request.id)) {
    query['Id'] = request.id;
  }
  if (!Util.isUnset(request.name)) {
    query['Name'] = request.name;
  }
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.phoneNumber)) {
    query['PhoneNumber'] = request.phoneNumber;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UpdateContacts',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function updateContacts(request: UpdateContactsRequest): UpdateContactsResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateContactsWithOptions(request, runtime);
}

model UpdateGroupDetailRequest {
  groupId?: string(name='GroupId'),
  id?: string(name='Id'),
  ownerId?: long(name='OwnerId'),
  poolKey?: string(name='PoolKey'),
  prodCode?: string(name='ProdCode'),
  remark?: string(name='Remark'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
}

model UpdateGroupDetailResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: boolean(name='data'),
}

model UpdateGroupDetailResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: UpdateGroupDetailResponseBody(name='body'),
}

async function updateGroupDetailWithOptions(request: UpdateGroupDetailRequest, runtime: Util.RuntimeOptions): UpdateGroupDetailResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.groupId)) {
    query['GroupId'] = request.groupId;
  }
  if (!Util.isUnset(request.id)) {
    query['Id'] = request.id;
  }
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.poolKey)) {
    query['PoolKey'] = request.poolKey;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.remark)) {
    query['Remark'] = request.remark;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UpdateGroupDetail',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function updateGroupDetail(request: UpdateGroupDetailRequest): UpdateGroupDetailResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateGroupDetailWithOptions(request, runtime);
}

model UpdateGroupInfoRequest {
  id?: string(name='Id'),
  name?: string(name='Name'),
  ownerId?: long(name='OwnerId'),
  poolKey?: string(name='PoolKey'),
  prodCode?: string(name='ProdCode'),
  remark?: string(name='Remark'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
}

model UpdateGroupInfoResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: boolean(name='data'),
}

model UpdateGroupInfoResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: UpdateGroupInfoResponseBody(name='body'),
}

async function updateGroupInfoWithOptions(request: UpdateGroupInfoRequest, runtime: Util.RuntimeOptions): UpdateGroupInfoResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.id)) {
    query['Id'] = request.id;
  }
  if (!Util.isUnset(request.name)) {
    query['Name'] = request.name;
  }
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.poolKey)) {
    query['PoolKey'] = request.poolKey;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.remark)) {
    query['Remark'] = request.remark;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UpdateGroupInfo',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function updateGroupInfo(request: UpdateGroupInfoRequest): UpdateGroupInfoResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateGroupInfoWithOptions(request, runtime);
}

model UpdatePoolNameRequest {
  billId?: string(name='BillId'),
  ownerId?: long(name='OwnerId'),
  poolName?: string(name='PoolName'),
  prodCode?: string(name='ProdCode'),
  resType?: int32(name='ResType'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
}

model UpdatePoolNameResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: string(name='data'),
}

model UpdatePoolNameResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: UpdatePoolNameResponseBody(name='body'),
}

async function updatePoolNameWithOptions(request: UpdatePoolNameRequest, runtime: Util.RuntimeOptions): UpdatePoolNameResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.billId)) {
    query['BillId'] = request.billId;
  }
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.poolName)) {
    query['PoolName'] = request.poolName;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.resType)) {
    query['ResType'] = request.resType;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UpdatePoolName',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function updatePoolName(request: UpdatePoolNameRequest): UpdatePoolNameResponse {
  var runtime = new Util.RuntimeOptions{};
  return updatePoolNameWithOptions(request, runtime);
}

model UpdateResRemarkRequest {
  billId?: string(name='BillId'),
  ownerId?: long(name='OwnerId'),
  prodCode?: string(name='ProdCode'),
  remark?: string(name='Remark'),
  resType?: int32(name='ResType'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
  secretNo?: string(name='SecretNo'),
}

model UpdateResRemarkResponseBody = {
  requestId?: string(name='RequestId'),
  code?: string(name='code'),
  data?: string(name='data'),
}

model UpdateResRemarkResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: UpdateResRemarkResponseBody(name='body'),
}

async function updateResRemarkWithOptions(request: UpdateResRemarkRequest, runtime: Util.RuntimeOptions): UpdateResRemarkResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.billId)) {
    query['BillId'] = request.billId;
  }
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.remark)) {
    query['Remark'] = request.remark;
  }
  if (!Util.isUnset(request.resType)) {
    query['ResType'] = request.resType;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  if (!Util.isUnset(request.secretNo)) {
    query['SecretNo'] = request.secretNo;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UpdateResRemark',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function updateResRemark(request: UpdateResRemarkRequest): UpdateResRemarkResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateResRemarkWithOptions(request, runtime);
}

model ValidateOrderRequest {
  ownerId?: long(name='OwnerId'),
  prodCode?: string(name='ProdCode'),
  resourceOwnerAccount?: string(name='ResourceOwnerAccount'),
  resourceOwnerId?: long(name='ResourceOwnerId'),
  data?: string(name='data'),
}

model ValidateOrderResponseBody = {
  code?: string(name='Code'),
  data?: string(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: string(name='Success'),
}

model ValidateOrderResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ValidateOrderResponseBody(name='body'),
}

async function validateOrderWithOptions(request: ValidateOrderRequest, runtime: Util.RuntimeOptions): ValidateOrderResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.prodCode)) {
    query['ProdCode'] = request.prodCode;
  }
  if (!Util.isUnset(request.resourceOwnerAccount)) {
    query['ResourceOwnerAccount'] = request.resourceOwnerAccount;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  if (!Util.isUnset(request.data)) {
    query['data'] = request.data;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ValidateOrder',
    version = '2017-08-30',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function validateOrder(request: ValidateOrderRequest): ValidateOrderResponse {
  var runtime = new Util.RuntimeOptions{};
  return validateOrderWithOptions(request, runtime);
}

